diff --git a/goldfish/liii/base.scm b/goldfish/liii/base.scm
index 85f27098c..e3e158d2c 100644
--- a/goldfish/liii/base.scm
+++ b/goldfish/liii/base.scm
@@ -19,7 +19,40 @@
           (srfi srfi-2)
           (srfi srfi-8)
   ) ;import
-  (export
+  (re-export
+    ; (scheme base) defined by R7RS
+    let-values
+    ; R7RS 5: Program Structure
+    define-values define-record-type
+    ; R7RS 6.2: Numbers
+    square exact inexact max min floor floor/ s7-floor ceiling s7-ceiling truncate truncate/ s7-truncate
+    round s7-round floor-quotient floor-remainder gcd lcm s7-lcm modulo exact-integer-sqrt
+    numerator denominator exact-integer? number->string string->number
+    ; R7RS 6.3: Booleans
+    boolean=?
+    ; R7RS 6.4: list
+    pair? cons car cdr set-car! set-cdr! caar cadr cdar cddr
+    null? list? make-list list length append reverse list-tail
+    list-ref list-set! memq memv member assq assv assoc list-copy
+    ; R7RS 6.5: Symbol
+    symbol? symbol=? string->symbol symbol->string
+    ; R7RS 6.6: Characters
+    digit-value
+    ; R7RS 6.7: String
+    string-copy
+    ; R7RS 6.8 Vector
+    vector->string string->vector vector-copy vector-copy! vector-fill!
+    ; R7RS 6.9 Bytevectors
+    bytevector? make-bytevector bytevector bytevector-length bytevector-u8-ref
+    bytevector-u8-set! bytevector-copy bytevector-append
+    utf8->string string->utf8 utf8-string-length u8-substring bytevector-advance-utf8
+    ; Input and Output
+    call-with-port port? binary-port? textual-port? input-port-open? output-port-open?
+    open-binary-input-file open-binary-output-file close-port eof-object
+    ; Control flow
+    string-map vector-map string-for-each vector-for-each
+    ; Exception
+    raise guard read-error? file-error?
     ; SRFI-2
     and-let*
     ; SRFI-8
@@ -38,6 +71,10 @@
     string->keyword
     symbol->keyword
     keyword->symbol
+  ) ;re-export
+  (export
+    ; workaround for binding s7 primitives
+    (rename vector-append vector-append)
     ; Extra routines
     loose-car
     loose-cdr
@@ -73,34 +110,51 @@
           ) ;lambda
       ) ;if
     ) ;define
-  
+
     (define (any? x) #t)
 
-    ; 0 clause BSD, from S7 repo stuff.scm
-    (define-macro (typed-lambda args . body)
-      ; (typed-lambda ((var [type])...) ...)
-      (if (symbol? args)
-          (apply lambda args body)
-          (let ((new-args (copy args)))
-            (do ((p new-args (cdr p)))
-                ((not (pair? p)))
-                (if (pair? (car p))
-                    (set-car! p (caar p))
-                ) ;if
-            ) ;do
-            `(lambda ,new-args
-               ,@(map
-                   (lambda (arg)
-                     (if (pair? arg)
-                         `(unless (,(cadr arg) ,(car arg))
-                            (error 'type-error
-                              "~S is not ~S~%" ',(car arg) ',(cadr arg)))
-                         (values)))
-                   args)
-               ,@body)
-          ) ;let
-      ) ;if
-    ) ;define-macro
+    (define-syntax let1
+      (syntax-rules ()
+        ((_ name1 value1 body ...)
+         (let ((name1 value1))
+           body ...))))
+
+    (define-syntax typed-lambda
+      (lambda (stx)
+        (define (split-args args)
+          (let loop ((args args))
+            (syntax-case args ()
+              ;; 结束条件
+              (() (values '() '()))
+
+              ;; 带有类型的变量: ((var type) . rest)
+              (((var type) . rest)
+               (let-values (((clean-rest checks-rest) (loop (syntax rest))))
+                 (values (cons (syntax var) clean-rest)
+                         (cons #'(unless (type var)
+                                   (error 'type-error "~S is not ~S" 'var 'type))
+                               checks-rest))))
+
+              ;; 普通变量或 rest 变量: (var . rest) 或只是 var
+              ((var . rest)
+               (let-values (((clean-rest checks-rest) (loop (syntax rest))))
+                 (values (cons (syntax var) clean-rest) checks-rest)))
+
+              ;; 点号后面的最后一个标识符 (例如 rest)
+              (var
+               (if (identifier? (syntax var))
+                   (values (syntax var) '())
+                   (raise-syntax-error #f "Invalid argument specification" stx (syntax var)))))))
+
+        (syntax-case stx ()
+          ((_ args body1 body2 ...)
+           (let-values (((clean-args checks) (split-args (syntax args))))
+             (with-syntax ((clean-args clean-args)
+                           ((check ...) checks)
+                           ((body ...) #'(body1 body2 ...)))
+               #'(lambda clean-args
+                   check ...
+                   body ...)))))))
 
-  ) ;begin
-) ;define-library
+  ) ; end of begin
+) ; end of define-library
diff --git a/goldfish/liii/bitwise.scm b/goldfish/liii/bitwise.scm
index a289ed67f..446881778 100644
--- a/goldfish/liii/bitwise.scm
+++ b/goldfish/liii/bitwise.scm
@@ -17,7 +17,7 @@
 (define-library (liii bitwise)
   (import (srfi srfi-151) (liii error))
   ; S7 built-in
-  (export lognot logand logior logxor ash)
+  (re-export lognot logand logior logxor ash)
   ; from (srfi srfi-151)
   (export bitwise-not bitwise-and bitwise-ior bitwise-xor bitwise-eqv bitwise-or bitwise-nor
           bitwise-nand bit-count bitwise-orc1 bitwise-orc2 bitwise-andc1 bitwise-andc2
diff --git a/goldfish/liii/case.scm b/goldfish/liii/case.scm
deleted file mode 100644
index 9a4145679..000000000
--- a/goldfish/liii/case.scm
+++ /dev/null
@@ -1,502 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii case)
-  (import (liii base))
-  (export case*)
-  (begin
-
-    ; 0 clause BSD, from S7 repo case.scm
-    (define case* 
-      (let
-        ((case*-labels (lambda (label)
-                         (let ((labels ((funclet ((funclet 'case*) 'case*-helper)) 'labels)))
-                           (labels (symbol->string label))) ; if ellipsis, this has been quoted by case*
-                         ) ;let
-         ) ;case*-labels
-
-         (case*-match?
-           (lambda* (matchee pattern (e (curlet)))
-             (let ((matcher ((funclet ((funclet 'case*) 'case*-helper)) 'handle-sequence)))
-               (or (equivalent? matchee pattern)
-                   (and (or (pair? matchee) 
-                          (vector? matchee))
-                     (begin
-                       (fill! ((funclet ((funclet 'case*) 'case*-helper)) 'labels) #f) ; clear labels
-                       ((matcher pattern e) matchee))
-                     ) ;begin
-                   ) ;and
-               ) ;or
-             ) ;let
-         ) ;case*-match?
-         (case*-helper
-          (with-let (unlet)
-            (define labels (make-hash-table))
-
-            (define (ellipsis? pat)
-              (and (undefined? pat)
-                (or (equal? pat #<...>)
-                    (let ((str (object->string pat)))
-                      (and (char-position #\: str)
-                           (string=? "...>" (substring str (- (length str) 4)))
-                      ) ;and
-                    ) ;let
-                ) ;or
-              ) ;and
-            ) ;define
-
-            (define (ellipsis-pair-position pos pat)
-              (and (pair? pat)
-                (if (ellipsis? (car pat))
-                    pos
-                    (ellipsis-pair-position (+ pos 1) (cdr pat))
-                ) ;if
-              ) ;and
-            ) ;define
-
-            (define (ellipsis-vector-position pat vlen)
-              (let loop ((pos 0))
-                (and (< pos vlen)
-                  (if (ellipsis? (pat pos))
-                    pos
-                    (loop (+ pos 1))
-                  ) ;if
-                ) ;and
-              ) ;let
-            ) ;define
-
-            (define (splice-out-ellipsis sel pat pos e)
-              (let
-                ((sel-len (length sel))
-                 (new-pat-len (- (length pat) 1))
-                 (ellipsis-label (and (not (eq? (pat pos) #<...>))              
-                                   (let* ((str (object->string (pat pos)))
-                                          (colon (char-position #\: str)))
-                                     (and colon
-                                          (substring str 2 colon)))
-                                     ) ;and
-                                   ) ;let*
-                 ) ;ellipsis-label
-                (let
-                  ((func (and (string? ellipsis-label)
-                           (let ((comma (char-position #\, ellipsis-label)))
-                             (and comma
-                                  (let ((str (substring ellipsis-label (+ comma 1))))
-                                    (set! ellipsis-label (substring ellipsis-label 0 comma))
-                                    (let ((func-val (symbol->value (string->symbol str) e)))
-                                      (if (undefined? func-val)
-                                          (error 'unbound-variable "function ~S is undefined\n" func)
-                                      ) ;if
-                                      (if (not (procedure? func-val))
-                                          (error 'wrong-type-arg "~S is not a function\n" func)
-                                      ) ;if
-                                      func-val)))
-                                    ) ;let
-                                  ) ;let
-                             ) ;and
-                           ) ;let
-                  (if (pair? pat)
-                      (cond ((= pos 0)               ; ellipsis at start of pattern
-                             (if ellipsis-label
-                               (set! (labels ellipsis-label) 
-                                     (list 'quote (copy sel (make-list (- sel-len new-pat-len))))
-                               ) ;set!
-                             ) ;if
-                             (values (list-tail sel (- sel-len new-pat-len))
-                               (cdr pat)
-                               (or (not func)
-                                 (func (cadr (labels ellipsis-label)))) ; value is (quote ...) and we want the original list here
-                               ) ;or
-                             ) ;values
-
-                        ((= pos new-pat-len)     ; ellipsis at end of pattern
-                         (if ellipsis-label
-                           (set! (labels ellipsis-label) 
-                                 (list 'quote (copy sel (make-list (- sel-len pos)) pos))
-                           ) ;set!
-                         ) ;if
-                         (values (copy sel (make-list pos))
-                           (copy pat (make-list pos))
-                           (or (not func) 
-                             (func (cadr (labels ellipsis-label)))
-                           ) ;or
-                         ) ;values
-                        ) ;
-
-                        (else                    ; ellipsis somewhere in the middle
-                         (let ((new-pat (make-list new-pat-len))
-                               (new-sel (make-list new-pat-len)))
-                           (if ellipsis-label
-                             (set! (labels ellipsis-label) 
-                               (list 'quote (copy sel (make-list (- sel-len new-pat-len)) pos))
-                             ) ;set!
-                           ) ;if
-                           (copy pat new-pat 0 pos)
-                           (copy pat (list-tail new-pat pos) (+ pos 1))
-                           (copy sel new-sel 0 pos)
-                           (copy sel (list-tail new-sel pos) (- sel-len pos))
-                           (values new-sel new-pat
-                             (or (not func) 
-                               (func (cadr (labels ellipsis-label)))
-                             ) ;or
-                           ) ;values
-                         ) ;let
-                        ) ;else
-                      ) ;cond
-
-                      (cond
-                        ((= pos 0)
-                         (if ellipsis-label
-                           (set! (labels ellipsis-label) 
-                                 (list 'quote (copy sel (make-list (- sel-len new-pat-len))))
-                           ) ;set!
-                         ) ;if
-                         (values (subvector sel (max 0 (- sel-len new-pat-len)) sel-len) ; was new-pat-len (max 0 (- sel-len new-pat-len))
-                           (subvector pat 1 (+ new-pat-len 1))                     ;     new-pat-len 1
-                           (or (not func) 
-                             (func (cadr (labels ellipsis-label))))
-                           ) ;or
-                         ) ;values
-
-                        ((= pos new-pat-len)
-                         (if ellipsis-label
-                           (set! (labels ellipsis-label) 
-                             (list 'quote (copy sel (make-list (- sel-len new-pat-len)) pos))
-                           ) ;set!
-                         ) ;if
-                         (values (subvector sel 0 new-pat-len)
-                           (subvector pat 0 new-pat-len)
-                           (or (not func) 
-                         (func (cadr (labels ellipsis-label)))
-                           ) ;or
-                         ) ;values
-                        ) ;
-
-                        (else
-                         (let ((new-pat (make-vector new-pat-len))
-                           (new-sel (make-vector new-pat-len)))
-                           (if ellipsis-label
-                         (set! (labels ellipsis-label) 
-                           (list 'quote (copy sel (make-list (- sel-len new-pat-len)) pos))
-                         ) ;set!
-                           ) ;if
-                           (copy pat new-pat 0 pos)
-                           (copy pat (subvector new-pat pos new-pat-len) (+ pos 1))       ; (- new-pat-len pos) pos)   copy: (+ pos 1))
-                           (copy sel new-sel 0 pos)
-                           (copy sel (subvector new-sel pos new-pat-len) (- sel-len pos))
-                           ; (- new-pat-len pos) pos)  copy: (- sel-len pos))
-                           (values new-sel new-pat
-                         (or (not func) 
-                           (cadr (func (labels ellipsis-label)))
-                         ) ;or
-                           ) ;values
-                         ) ;let
-                        ) ;else
-                      ) ;cond
-                  ) ;if
-                ) ;let
-              ) ;let
-            ) ;define
-
-            (define (handle-regex x) #f)
-            ;(define handle-regex
-            ;  (let ((rg ((*libc* 'regex.make))) ; is this safe?
-            ;  (local-regcomp (*libc* 'regcomp))
-            ;  (local-regerror (*libc* 'regerror))
-            ;  (local-regexec (*libc* 'regexec))
-            ;  (local-regfree (*libc* 'regfree)))
-            ;    (lambda (reg)
-            ;(lambda (x)
-            ;  (and (string? x)
-            ; (let ((res (local-regcomp rg (substring reg 1 (- (length reg) 1)) 0)))
-            ;   (unless (zero? res)
-            ;     (error 'regex-error "~S~%" (local-regerror res rg)))
-            ;   (set! res (local-regexec rg x 0 0))
-            ;   (local-regfree rg)
-            ;   (zero? res)))))))
-
-            (define (undefined->function undef e)   ; handle the pattern descriptor ("undef") of the form #< whatever >, "e" = caller's curlet
-              (let* ((str1 (object->string undef))
-                     (str1-end (- (length str1) 1)))
-                (if (not (char=? (str1 str1-end) #\>))
-                  (error 'wrong-type-arg "pattern descriptor does not end in '>': ~S\n" str1)
-                ) ;if
-                (let ((str (substring str1 2 str1-end)))
-                  (if (= (length str) 0)                                           ; #<> = accept anything
-                      (lambda (x) #t)
-                      (let ((colon (char-position #\: str)))
-                        (cond (colon                                               ; #<label:...> might be #<label:> or #<label:func>
-                                (let ((label (substring str 0 colon))               ; str is label:...
-                                      (func (substring str (+ colon 1))))           ; func might be ""
-                                  (cond ((labels label)                             ; see if we already have saved something under this label
-                                         (lambda (sel)                              ;   if so, return function that will return an error
-                                           (error 'syntax-error "label ~S is defined twice: old: ~S, new: ~S~%" label (labels label) sel))
-                                         ) ;lambda
-
-                                        ;; otherwise the returned function needs to store the current sel-item under label in labels
-                                        ((zero? (length func))
-                                         (lambda (x)
-                                           (set! (labels label) x)                  ; #<label:>, set label, accept anything
-                                           #t
-                                         ) ;lambda
-                                        ) ;
-
-                                        ((char=? (func 0) #\")                      ; labelled regex, #<label:"regexp">
-                                         (lambda (x)
-                                           (set! (labels label) x)
-                                           (handle-regex func)
-                                         ) ;lambda
-                                        ) ;
-
-                                        (else                                       ; #<label:func>
-                                         (let ((func-val (symbol->value (string->symbol func) e)))
-                                           (if (undefined? func-val)
-                                               (error 'unbound-variable "function ~S is undefined\n" func)
-                                               (if (not (procedure? func-val))
-                                                 (error 'wrong-type-arg "~S is not a function\n" func)
-                                                 (lambda (x)                     ; set label and call func
-                                                   (set! (labels label) x)
-                                                   (func-val x))
-                                                 ) ;lambda
-                                               ) ;if
-                                           ) ;if
-                                         ) ;let
-                                        ) ;else
-                                  ) ;cond
-                                ) ;let
-
-                          ;; if no colon either #<label> or #<func> or #<"regexp"> -- label means match its saved expr, func = call func
-                          ((char=? (str 0) #\")
-                           (handle-regex str)
-                          ) ;
-
-                          (else                                                ; #<label> or #<func>
-                           (let ((saved (labels str)))
-                             (if saved                                         ; #<label>
-                                 (lambda (x) (equivalent? x saved))
-                                 (symbol->value (string->symbol str) e) ; #<func> using curlet=e passed in above
-                             ) ;if
-                           ) ;let
-                          ) ;else
-                        ) ;cond
-                      ) ;let
-                  ) ;if
-                ) ;let
-              ) ;let*
-            ) ;define
-
-            (define (handle-pattern sel-item pat-item e)
-              (and (undefined? pat-item)      ; turn #<func> into func and call it on the current selector element
-                (not (eq? pat-item #<undefined>))
-                (let ((func (undefined->function pat-item e)))
-                  (if (undefined? func)
-                    (error 'unbound-variable "function ~S is undefined\n" pat-item)
-                  ) ;if
-                  (if (not (procedure? func))
-                    (error 'wrong-type-arg "~S is not a function\n" func)
-                  ) ;if
-                  (func sel-item)
-                ) ;let
-              ) ;and
-            ) ;define
-
-            (define (handle-sequence pat e)
-              (lambda (sel)
-                ;(format *stderr* "~S ~S~%" sel pat)
-                (and (eq? (type-of sel) (type-of pat))
-                  (let ((func-ok #t))
-
-                    (when (or (pair? pat)                           ; look for ellipsis
-                            (vector? pat))
-                      (if (pair? (cyclic-sequences pat))
-                          (error 'wrong-type-arg "case* pattern is cyclic: ~S~%" pat)
-                      ) ;if
-                      (let ((pos (if (pair? pat)
-                                   (ellipsis-pair-position 0 pat)
-                                   (ellipsis-vector-position pat (length pat)))))
-                        (when (and pos
-                                (>= (length sel) (- (length pat) 1))) ; else pat without ellipsis is too long for sel
-                          (let ((new-vars (list (splice-out-ellipsis sel pat pos e))))
-                            (set! sel (car new-vars))
-                            (set! pat (cadr new-vars))
-                            (set! func-ok (caddr new-vars))
-                          ) ;let
-                        ) ;when
-                      ) ;let
-                    ) ;when
-
-                    (and (= (length sel) (length pat))             ; march through selector and current target matching elements
-                      func-ok
-                      (call-with-exit
-                       (lambda (return)
-                         (for-each 
-                          (lambda (sel-item pat-item)
-                            (or (equivalent? sel-item pat-item) ; items match
-
-                                (and (or (pair? pat-item)       ; recursive check (* (+ #<symbol?> 1) 2), pat-item: (+ #symbol?> 1)
-                                       (vector? pat-item))    ; pat-item, not sel-item here so pat-item can cover anything (a list for example)
-                                  ((handle-sequence pat-item e) sel-item)
-                                ) ;and
-
-                                (handle-pattern sel-item pat-item e)
-
-                                (return #f)                   ; else give up (selector does not match target)
-                            ) ;or
-                          ) ;lambda
-                          sel pat
-                         ) ;for-each
-
-                         ;; dotted list, check final cdr
-                         (unless (or (not (pair? sel)) 
-                                   (proper-list? sel))
-                           (let ((sel-item (list-tail sel (abs (length sel))))
-                                 (pat-item (list-tail pat (abs (length pat)))))
-                             (return (or (equivalent? sel-item pat-item)
-                                       (handle-pattern sel-item pat-item e))
-                             ) ;return
-                           ) ;let
-                         ) ;unless
-
-                         #t
-                       ) ;lambda
-                      ) ;call-with-exit
-                    ) ;and
-                  ) ;let
-                ) ;and
-              ) ;lambda
-            ) ;define
-
-            (define (find-labelled-pattern tree)
-              ;; walk body looking for a labelled pattern
-              (or (undefined? tree)
-                (and (pair? tree)
-                     (or (find-labelled-pattern (car tree))
-                       (find-labelled-pattern (cdr tree))
-                     ) ;or
-                ) ;and
-                (and (vector? tree)
-                     (let vector-walker ((pos 0))
-                       (and (< pos (length tree))
-                            (or (undefined? (tree pos))
-                              (and (pair? (tree pos))
-                                   (find-labelled-pattern (tree pos))
-                              ) ;and
-                              (and (vector? (tree pos))
-                                   (vector-walker (tree pos))
-                              ) ;and
-                              (vector-walker (+ pos 1))
-                            ) ;or
-                       ) ;and
-                     ) ;let
-                ) ;and
-              ) ;or
-            ) ;define
-
-            (define (handle-body select body return e)
-              (if (null? body)
-                (return select)
-              ) ;if
-
-              (when (find-labelled-pattern body) ; if labelled, remake the body substituting the labelled-exprs for the labels
-                (set! body (let pair-builder ((tree body))
-                             (cond
-                               ((undefined? tree)
-                                (let ((label (let ((str (object->string tree)))
-                                               (substring str 2 (- (length str) 1)))))
-                                  (or (labels label) tree)
-                                ) ;let
-                               ) ;
-
-                               ((pair? tree)
-                                (cons (pair-builder (car tree))
-                                  (pair-builder (cdr tree))
-                                ) ;cons
-                               ) ;
-
-                               ((vector? tree)
-                                (vector (map pair-builder tree))
-                               ) ;
-
-                               (else tree))
-                             ) ;cond
-                ) ;set!
-              ) ;when
-
-              ;; evaluate the result (case* expands into a call on case*-helper; we need to evaluate the result expressions ourselves)
-              (return (eval (if (null? (cdr body))
-                              (car body)
-                              (if (eq? (car body) '=>)
-                                (list (cadr body) select)
-                                (cons 'begin body))
-                              ) ;if
-                        e)
-              ) ;return
-            ) ;define
-
-            ;; case*-helper
-            (lambda (select clauses e)
-              (call-with-exit
-               (lambda (return)
-                 (for-each
-                  (lambda (clause)                                        ;((target...) body...)
-                    (let ((targets (car clause))
-                          (body (cdr clause)))
-                      (fill! labels #f)                                   ; clear previous labels
-                      (if (memq targets '(else #t))                       ; (else...) or (#t...)
-                        (return (eval (cons 'begin body) e))
-                        (for-each
-                         (lambda (target)
-                           (if (or (equivalent? target select)
-                                 (and (undefined? target)              ; #<...>
-                                   (not (eq? target #<undefined>))
-                                   (let ((func (undefined->function target e)))
-                                     ;(format *stderr* "func: ~S~%" func)
-                                     ;; (if (undefined? func) (error 'unbound-variable "function ~A is undefined\n" str))
-                                     ;; not the above check because we want to be able to pass patterns as selectors! (scase37 in s7test)
-                                     ;;    this seems like a mistake: #<symbol?> won't work? 
-                                     (and (procedure? func)
-                                       (func select)
-                                     ) ;and
-                                   ) ;let
-                                 ) ;and
-                                 (and (sequence? target)
-                                   ((handle-sequence target e) select))
-                                 ) ;and
-                             (handle-body select body return e)
-                           ) ;if
-                         ) ;lambda
-                         targets
-                        ) ;for-each
-                      ) ;if
-                    ) ;let
-                  ) ;lambda
-                  clauses)
-                 ) ;for-each
-               ) ;lambda
-              ) ;call-with-exit
-            ) ;lambda
-          ) ;with-let
-         ) ;case*-helper
-        ;; case*
-        (#_macro (selector . clauses)
-          `(((#_funclet 'case*) 'case*-helper) ,selector ',clauses (#_curlet))
-        ) ;_macro
-      ) ;let
-    ) ;define
-
-  ) ;begin
-) ;define-library
-
diff --git a/goldfish/liii/check.scm b/goldfish/liii/check.scm
index cc81e6e3f..e38be956d 100644
--- a/goldfish/liii/check.scm
+++ b/goldfish/liii/check.scm
@@ -26,82 +26,17 @@
   ) ;import
   (begin
 
-    (define-macro (check-true body)
-      `(check ,body => #t)
-    ) ;define-macro
+    (define-syntax-rule (check-true body)
+      (check body => #t))
 
-    (define-macro (check-false body)
-      `(check ,body => #f)
-    ) ;define-macro
+    (define-syntax-rule (check-false body)
+      (check body => #f))
 
-    (define default-check-approx-rel-tol 1e-12)
-    (define default-check-approx-abs-tol 1e-12)
+    (define-syntax-rule (check-catch error-id body)
+      (check (catch error-id (lambda () body) (lambda args error-id)) => error-id))
 
-    (define (parse-check-approx-options options)
-      (let loop ((remaining options)
-                 (rel-tol default-check-approx-rel-tol)
-                 (abs-tol default-check-approx-abs-tol))
-        (cond
-          ((null? remaining)
-           (cons rel-tol abs-tol)
-          ) ;
-          ((null? (cdr remaining))
-           (error "check-approx option requires a value" (car remaining))
-          ) ;
-          ((equal? (car remaining) :rel-tol)
-           (loop (cddr remaining) (cadr remaining) abs-tol)
-          ) ;
-          ((equal? (car remaining) :abs-tol)
-           (loop (cddr remaining) rel-tol (cadr remaining))
-          ) ;
-          (else
-           (error "check-approx unrecognized option" (car remaining))
-          ) ;else
-        ) ;cond
-      ) ;let
-    ) ;define
-
-    (define-macro (check-approx expr => expected . options)
-      (let* ((parsed (parse-check-approx-options options))
-             (rel-tol (car parsed))
-             (abs-tol (cdr parsed)))
-        `(check:proc ',expr
-                     (lambda () ,expr)
-                     ,expected
-                     (lambda (actual expected)
-                       (and (number? actual)
-                            (number? expected)
-                            (number? ,rel-tol)
-                            (number? ,abs-tol)
-                            (or (= actual expected)
-                                (let*
-                                  ((difference (abs (- actual expected)))
-                                   (relative-tolerance (abs ,rel-tol))
-                                   (absolute-tolerance (abs ,abs-tol))
-                                   (scale (max (abs actual) (abs expected)))
-                                   (limit
-                                     (max absolute-tolerance
-                                          (* relative-tolerance scale))))
-                                  (<= difference limit)
-                                ) ;let*
-                            ) ;or
-                       ) ;and
-                     ) ;lambda
-        ) ;quasiquote
-      ) ;let*
-    ) ;define-macro
-
-    (define-macro (check-catch error-id body)
-      `(check
-        (catch ,error-id
-          (lambda () ,body)
-          (lambda args ,error-id))
-        => ,error-id)
-    ) ;define-macro
-
-    (define-macro (test left right)
-      `(check ,left => ,right)
-    ) ;define-macro
+    (define-syntax-rule (test left right)
+      (check left => right))
 
     (define (check-report . msg)
       (if (not (null? msg))
diff --git a/goldfish/liii/raw-string.scm b/goldfish/liii/raw-string.scm
index 551e2d66b..05d4b440a 100644
--- a/goldfish/liii/raw-string.scm
+++ b/goldfish/liii/raw-string.scm
@@ -101,12 +101,14 @@
       ) ;let*
     ) ;define
 
-    (define-macro (stx-deindent v)
-      (if (string? v)
-          `(quote ,(f-deindent v))
-          `(quote ,v)
-      ) ;if
-    ) ;define-macro
+    (define-syntax stx-deindent
+      (lambda (stx)
+        (syntax-case stx ()
+          ((_ v)
+           (let ((val (syntax->datum #'v)))
+             (if (string? val)
+                 (datum->syntax stx (f-deindent val))
+                 #'(quote v))))))
 
     (define deindent stx-deindent)
     (define &-       stx-deindent)
diff --git a/goldfish/liii/string.scm b/goldfish/liii/string.scm
index 01aee12b1..8224acf61 100644
--- a/goldfish/liii/string.scm
+++ b/goldfish/liii/string.scm
@@ -16,6 +16,10 @@
 
 (define-library (liii string)
   (export
+    ; S7 built-in
+    (rename string? string?) (rename string-ref string-ref) (rename string-length string-length)
+    ; from (scheme base)
+    string-copy string-for-each string-map
     ; from (srfi srfi-13)
     string-null? string-join
     string-every string-any
diff --git a/goldfish/scheme/base.scm b/goldfish/scheme/base.scm
index d98e3d677..11f88ebd4 100644
--- a/goldfish/scheme/base.scm
+++ b/goldfish/scheme/base.scm
@@ -15,10 +15,7 @@
 ;
 
 (define-library (scheme base)
-  (export
-    let-values
-    ; R7RS 5: Program Structure
-    define-values define-record-type
+  (re-export
     ; R7RS 6.1: Equivalence predicates
     eq? eqv? equal?
     ; R7RS 6.2: Numbers
@@ -26,129 +23,193 @@
     = < > <= >=
     + - * / abs
     ; - 数值函数
-    square exact inexact max min floor floor/ s7-floor ceiling s7-ceiling truncate truncate/ s7-truncate
-    round s7-round floor-quotient floor-remainder gcd lcm s7-lcm modulo quotient remainder
-    numerator denominator rationalize exact-integer-sqrt
+    gcd quotient remainder
+    numerator denominator rationalize
     number->string string->number
     ; - 类型判断
-    number? complex? real? rational? integer? exact? inexact? exact-integer?
+    number? complex? real? rational? integer? exact? inexact?
     positive? negative? zero? odd? even?
     ; R7RS 6.3: Booleans
-    not boolean=? boolean?
+    not boolean?
     ; R7RS 6.4: list
     pair? cons car cdr set-car! set-cdr! caar cadr cdar cddr
     null? list? make-list list length append reverse list-tail
-    list-ref list-set! memq memv member assq assv assoc list-copy map
+    list-ref list-set! memq memv member assq assv assoc
     ; R7RS 6.5: Symbol
-    symbol? symbol=? string->symbol symbol->string
+    symbol? string->symbol symbol->string
     ; R7RS 6.6: Characters
     char? char=? char<? char>? char<=? char>=? char->integer integer->char
     ; R7RS 6.7: String
     string? make-string string string-length string-ref string-set!
-    string-copy string-append substring string-fill!
+    string-append substring string-fill!
     string->list list->string
     string=? string<? string>? string<=? string>=?
     ; R7RS 6.8: Vector
     vector? make-vector vector vector-length vector-ref vector-set!
-    vector->list list->vector vector->string string->vector
-    vector-copy vector-copy! vector-fill! vector-append
+    vector->list list->vector
+    vector-append
+    open-output-string open-input-string get-output-string
+  ) ;re-export
+  (export
+    let-values
+    ; R7RS 5: Program Structure
+    define-values define-record-type
+    %define-record-fields %define-record-field
+
+    exact inexact max min
+    s7-floor floor floor/
+    s7-ceiling ceiling
+    s7-round round
+    s7-lcm lcm
+    s7-truncate truncate truncate/
+    floor-quotient floor-remainder modulo square
+    exact-integer-sqrt
+    exact-integer? boolean=? symbol=?
     ; R7RS 6.9: Bytevectors
     bytevector? make-bytevector bytevector bytevector-length bytevector-u8-ref
     bytevector-u8-set! bytevector-copy bytevector-append
     utf8->string string->utf8 utf8-string-length bytevector-advance-utf8
+ 
+    ; Exception
+    raise guard read-error? file-error?
     ; Input and Output
     call-with-port port? binary-port? textual-port? input-port-open? output-port-open?
-    open-binary-input-file open-binary-output-file close-port eof-object
+    (rename open-input-file  open-binary-input-file)
+    (rename open-output-file open-binary-output-file)
+    close-port eof-object
+
+    string-copy
     ; Control flow
     string-map vector-map string-for-each vector-for-each
-    ; Exception
-    raise guard read-error? file-error?
+
+    vector-copy vector-copy! vector-fill! vector->string string->vector
+
+    (rename copy list-copy)
   ) ;export
   (begin
 
     ; 0-clause BSD
     ; Bill Schottstaedt
     ; from S7 source repo: r7rs.scm
-    (define-macro (let-values vars . body)
-      (if (and (pair? vars)
-               (pair? (car vars))
-               (null? (cdar vars)))
-          `((lambda ,(caar vars)
-              ,@body)
-            ,(cadar vars))
-          `(with-let
-            (apply sublet (curlet)
-              (list
-                ,@(map
-                   (lambda (v)
-                     `((lambda ,(car v)
-                         (values ,@(map (lambda (name)
-                                          (values (symbol->keyword name) name))
-                                     (let args->proper-list ((args (car v)))
-                                       (cond
-                                         ((symbol? args)
-                                          (list args))
-                                         ((not (pair? args))
-                                          args)
-                                         ((pair? (car args))
-                                          (cons (caar args)
-                                                (args->proper-list (cdr args))))
-                                         (else
-                                          (cons (car args)
-                                                (args->proper-list (cdr args)))))))))
-                       ,(cadr v)))
-                   vars)))
-            ,@body)
-      ) ;if
-    ) ;define-macro
+    (define-syntax let-values
+      (lambda (x)
+        (syntax-case x ()
+          ((_ ((binds exp)) b0 b1 ...)
+           (syntax (call-with-values (lambda () exp)
+                     (lambda binds b0 b1 ...))))
+          ((_ (clause ...) b0 b1 ...)
+           (let lp ((clauses (syntax (clause ...)))
+                    (ids '())
+                    (tmps '()))
+             (if (null? clauses)
+                 (with-syntax (((id ...) ids)
+                               ((tmp ...) tmps))
+                   (syntax (let ((id tmp) ...)
+                             b0 b1 ...)))
+                 (syntax-case (car clauses) ()
+                   (((var ...) exp)
+                    (with-syntax (((new-tmp ...) (generate-temporaries
+                                                  (syntax (var ...))))
+                                  ((id ...) ids)
+                                  ((tmp ...) tmps))
+                      (with-syntax ((inner (lp (cdr clauses)
+                                               (syntax (var ... id ...))
+                                               (syntax (new-tmp ... tmp ...)))))
+                        (syntax (call-with-values (lambda () exp)
+                                  (lambda (new-tmp ...) inner))))))
+                   ((vars exp)
+                    (with-syntax ((((new-var . new-tmp) ...)
+                                   (let lp ((vars (syntax vars)))
+                                     (syntax-case vars ()
+                                       ((id . rest)
+                                        (acons (syntax id)
+                                               (car
+                                                (generate-temporaries (syntax (id))))
+                                               (lp (syntax rest))))
+                                       (id (acons (syntax id)
+                                                  (car
+                                                   (generate-temporaries (syntax (id))))
+                                                  '())))))
+                                  ((id ...) ids)
+                                  ((tmp ...) tmps))
+                      (with-syntax ((inner (lp (cdr clauses)
+                                               (syntax (new-var ... id ...))
+                                               (syntax (new-tmp ... tmp ...))))
+                                    (args (let lp ((tmps (syntax (new-tmp ...))))
+                                            (syntax-case tmps ()
+                                              ((id) (syntax id))
+                                              ((id . rest) (cons (syntax id)
+                                                                 (lp (syntax rest))))))))
+                        (syntax (call-with-values (lambda () exp)
+                                  (lambda args inner)))))))))))))
 
     ; 0-clause BSD by Bill Schottstaedt from S7 source repo: s7test.scm
-    (define-macro (define-values vars expression)
-      `(if (not (null? ',vars))
-           (varlet (curlet) ((lambda ,vars (curlet)) ,expression)))
-    ) ;define-macro
-
-    ; 0-clause BSD by Bill Schottstaedt from S7 source repo: r7rs.scm
-    (define-macro (define-record-type type make ? . fields)
-      (let
-        ((obj (gensym))
-         (typ (gensym)) ; this means each call on this macro makes a new type
-         (args
-           (map
-             (lambda (field)
-               (values (list 'quote (car field))
-                       (let ((par (memq (car field) (cdr make))))
-                         (and (pair? par) (car par)))
-                       ) ;let
-               ) ;values
-             fields)
-           ) ;map
-         ) ;args
-        `(begin
-           (define (,? ,obj)
-             (and (let? ,obj)
-                  (eq? (let-ref ,obj ',typ) ',type)))
-       
-           (define ,make 
-             (inlet ',typ ',type ,@args))
-
-           ,@(map
-              (lambda (field)
-                (when (pair? field)
-                  (if (null? (cdr field))
-                      (values)
-                      (if (null? (cddr field))
-                          `(define (,(cadr field) ,obj)
-                             (let-ref ,obj ',(car field)))
-                          `(begin
-                             (define (,(cadr field) ,obj)
-                               (let-ref ,obj ',(car field)))
-                             (define (,(caddr field) ,obj val)
-                               (let-set! ,obj ',(car field) val)))))))
-              fields)
-           ',type)
-      ) ;let
-    ) ;define-macro
+    (define-syntax define-values
+      (lambda (stx)
+        (syntax-case stx ()
+          ((_ () expr)
+           (with-syntax (((dummy) (generate-temporaries '(dummy))))
+             #'(define dummy (call-with-values (lambda () expr) (lambda () (if #f #f))))))
+          ((_ (var) expr)
+           #'(define var (call-with-values (lambda () expr) (lambda (v) v))))
+          ((_ (var ...) expr)
+           (with-syntax (((tmp ...) (generate-temporaries #'(var ...))))
+             #'(begin
+                 (define var (if #f #f)) ...
+                 (call-with-values (lambda () expr)
+                   (lambda (tmp ...)
+                     (set! var tmp) ...))))))))
+
+    (define-syntax define-record-type
+      (lambda (stx)
+        (syntax-case stx ()
+          ((_ type-name (make-name field-var ...) pred-name field-spec ...)
+           (with-syntax (((field-index ...)
+                          (let loop ((specs #'(field-spec ...))
+                                     (idx 1)
+                                     (acc '()))
+                            (if (null? specs)
+                                (reverse acc)
+                                (loop (cdr specs) (+ idx 1) (cons idx acc))))))
+             #'(begin
+                 (define type-tag (list 'type-name))
+                 (define (pred-name obj)
+                   (and (vector? obj)
+                        (> (vector-length obj) 0)
+                        (eq? (vector-ref obj 0) type-tag)))
+                 (define (make-name field-var ...)
+                   (vector type-tag field-var ...))
+                 (%define-record-fields type-tag pred-name
+                   ((field-spec field-index) ...))
+                 (define type-name type-tag)))))))
+
+    (define-syntax %define-record-fields
+      (syntax-rules ()
+        ((_ type-tag pred-name ((spec idx) ...))
+         (begin (%define-record-field type-tag pred-name spec idx) ...))))
+
+    (define-syntax %define-record-field
+      (syntax-rules ()
+        ;; (field)
+        ((_ type-tag pred-name (field) idx)
+         (begin))
+        ;; (field getter)
+        ((_ type-tag pred-name (field getter) idx)
+         (define (getter obj)
+           (if (pred-name obj)
+               (vector-ref obj idx)
+               (error 'getter "invalid record type"))))
+        ;; (field getter setter)
+        ((_ type-tag pred-name (field getter setter) idx)
+         (begin
+           (define (getter obj)
+             (if (pred-name obj)
+                 (vector-ref obj idx)
+                 (error 'getter "invalid record type")))
+           (define (setter obj val)
+             (if (pred-name obj)
+                 (vector-set! obj idx val)
+                 (error 'setter "invalid record type")))))))
 
     (define exact inexact->exact)
 
@@ -665,22 +726,22 @@ wrong-type-arg
       (apply throw #t args)
     ) ;define
 
-    (define-macro (guard results . body)
-      `(let
-         ((,(car results)
-           (catch #t 
-             (lambda () 
-               ,@body) 
-             (lambda (type info)
-               (if (pair? (*s7* 'catches))
-                   (lambda () (apply throw type info))
-                   (car info))))))
-         (cond ,@(cdr results)
-               (else 
-                (if (procedure? ,(car results)) 
-                    (,(car results))
-                    ,(car results)))))
-    ) ;define-macro
+    (define-syntax guard
+      (lambda (stx)
+        (syntax-case stx ()
+          ((_ (var clause ...) body ...)
+           #'(let ((var
+                    (catch #t
+                      (lambda () body ...)
+                      (lambda (type info)
+                        (if (pair? (*s7* 'catches))
+                            (lambda () (apply throw type info))
+                            (car info))))))
+               (cond clause ...
+                     (else
+                      (if (procedure? var)
+                          (var)
+                          var))))))))
 
     (define (read-error? obj) (eq? (car obj) 'read-error))
 
@@ -710,10 +771,10 @@ wrong-type-arg
       ) ;if
     ) ;define
 
-    (define (eof-object) #<eof>)
+    (define (eof-object) (call-with-input-string "" read))
 
     ; 0 clause BSD, from S7 repo r7rs.scm
-    (define list-copy copy)
+    ; (define list-copy copy)
 
     (define (string-copy str . start_end)
       (cond
diff --git a/goldfish/scheme/boot.scm b/goldfish/scheme/boot.scm
index e3748d620..bfa2646f7 100644
--- a/goldfish/scheme/boot.scm
+++ b/goldfish/scheme/boot.scm
@@ -1,135 +1,216 @@
-(unless (defined? 'texmacs-module)
-  (set! (*s7* 'scheme-version) 'r7rs)
-) ;unless
-
-(define (file-exists? path)
-  (if (string? path)
-    (if (not (g_access path 0)) ; F_OK
-      #f
-      (if (g_access path 1) ; R_OK
-          #t
-          (error 'permission-error (string-append "No permission: " path))
-      ) ;if
-    ) ;if
-    (error 'type-error "(file-exists? path): path should be string")
-  ) ;if
-) ;define
-
-(define (delete-file path)
-  (if (not (string? path))
-    (error 'type-error "(delete-file path): path should be string")
-    (if (not (file-exists? path))
-      (error 'read-error (string-append path " does not exist"))
-      (g_delete-file path)
-    ) ;if
-  ) ;if
-) ;define
-
-; 0-clause BSD
-; Adapted from S7 Scheme's r7rs.scm
-(define-macro (define-library libname . body) ; |(lib name)| -> environment
-  `(define ,(symbol (object->string libname))
-     (with-let (sublet (unlet)
-                 (cons 'import import)
-                 (cons '*export* ())
-                 (cons 'export (define-macro (,(gensym) . names)
-                                 `(set! *export* (append ',names *export*)))))
-       ,@body
-       (apply inlet
-              (map
-                (lambda (entry)
-                  (if (or (member (car entry) '(*export* export import))
-                          (and (pair? *export*)
-                               (not (member (car entry) *export*))))
-                      (values)
-                      entry))
-                (curlet)))))
-) ;define-macro
-
-(unless (defined? 'r7rs-import-library-filename)
-  (define (r7rs-import-library-filename libs)
-    (when (pair? libs)
-      (let
-        ((lib-filename (let loop ((lib (if (memq (caar libs) '(only except prefix rename))
-                                           (cadar libs)
-                                           (car libs)))
-                                  (name ""))
-                         (set! name (string-append name (symbol->string (car lib))))
-                         (if (null? (cdr lib))
-                             (string-append name ".scm")
-                             (begin
-                               (set! name (string-append name "/"))
-                               (loop (cdr lib) name))
-                             ) ;begin
-                         ) ;if
-                             ) ;begin
-         ) ;lib-filename
-        (when (not (defined? (symbol (object->string (car libs)))))
-          ;(display "Loading ") (display lib-filename) (newline)
-          (load lib-filename)
-        ) ;when
-        (r7rs-import-library-filename (cdr libs)))
-      ) ;let
-    ) ;when
- ;define
-) ;unless
-
-(define-macro (import . libs)
-  `(begin
-     (r7rs-import-library-filename ',libs)
-     (varlet (curlet)
-       ,@(map
-           (lambda (lib)
-             (case (car lib)
-               ((only)
-                `((lambda (e names)
-                    (apply inlet
-                           (map
-                             (lambda (name)
-                               (cons name (e name)))
-                             names)))
-                  (symbol->value (symbol (object->string (cadr ',lib))))
-                  (cddr ',lib)))
-               ((except)
-                `((lambda (e names)
-                    (apply inlet
-                           (map
-                             (lambda (entry)
-                               (if (member (car entry) names)
-                                   (values)
-                                   entry))
-                             e)))
-                  (symbol->value (symbol (object->string (cadr ',lib))))
-                  (cddr ',lib)))
-               ((prefix)
-                `((lambda (e prefx)
-                    (apply inlet
-                           (map
-                             (lambda (entry)
-                               (cons (string->symbol 
-                                      (string-append (symbol->string prefx) 
-                                                     (symbol->string (car entry)))) 
-                                     (cdr entry)))
-                             e)))
-                  (symbol->value (symbol (object->string (cadr ',lib))))
-                  (caddr ',lib)))
-               ((rename)
-                `((lambda (e names)
-                    (apply inlet
-                           (map
-                             (lambda (entry)
-                               (let ((info (assoc (car entry) names)))
-                                 (if info
-                                     (cons (cadr info) (cdr entry))
-                                     entry))) 
-                             e)))
-                  (symbol->value (symbol (object->string (cadr ',lib))))
-                  (cddr ',lib)))
-               (else
-                `(let ((sym (symbol (object->string ',lib))))
-                   (if (not (defined? sym))
-                       (format () "~A not loaded~%" sym)
-                       (symbol->value sym))))))
-           libs)))
-) ;define-macro
+(define (void) (if #f #f))
 
+(define (andmap f first . rest)
+  (if (null? rest)
+      (let andmap ((first first))
+        (if (null? first)
+            #t
+            (let ((x (car first))
+                  (rest (cdr first)))
+              (if (null? rest)
+                  (f x)
+                  (and (f x) (andmap rest))))))
+      (let andmap ((first first) (rest rest))
+        (if (null? first)
+            #t
+            (let ((x (car first))
+                  (xr (map car rest))
+                  (next-first (cdr first))
+                  (next-rest (map cdr rest)))
+              (if (null? next-first)
+                  (apply f (cons x xr))
+                  (and (apply f (cons x xr))
+                       (andmap next-first next-rest))))))))
+
+(define (ormap f list1)
+  (and (not (null? list1))
+       (or (f (car list1))
+           (ormap f (cdr list1)))))
+
+(define *symbol-properties* (make-hash-table))
+
+(define (putprop symbol key value)
+  (let ((props (hash-table-ref *symbol-properties* symbol)))
+    (if props
+        (hash-table-set! props key value)
+        (let ((new-props (make-hash-table)))
+          (hash-table-set! new-props key value)
+          (hash-table-set! *symbol-properties* symbol new-props)))
+    value))
+
+(define (getprop symbol key)
+  (let ((props (hash-table-ref *symbol-properties* symbol)))
+    (if props
+        (hash-table-ref props key)
+        #f)))
+
+(define (remprop symbol key)
+  (let ((props (hash-table-ref *symbol-properties* symbol)))
+    (if props
+        (hash-table-set! props key #f))
+    #f))
+
+(define s7-gensym gensym)
+(define (gensym x)
+  (cond
+    ((symbol? x) (s7-gensym (symbol->string x)))
+    (else        (s7-gensym x))))
+
+;; API provided by psyntax
+(define $sc-put-cte             #f)
+(define sc-expand               #f)
+(define $make-environment       #f)
+(define environment?            #f)
+(define interaction-environment #f)
+(define identifier?             #f)
+(define unwrap-syntax           #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)
+
+(define syntax->vector          #f)
+
+(set! (*s7* 'symbol-quote?) #t)
+
+(define s7-append append)
+(set! append
+  (lambda args
+    (cond
+      ;; 0 或 1 个参数
+      ((or (null? args) (null? (cdr args)))
+       (apply s7-append args))
+
+      ((not (proper-list? (car (last-pair args))))
+       (let ((prefix (apply s7-append (drop-right args 1))))
+         (if (null? prefix)
+             (car (last-pair args))
+             (let copy ((lst prefix))
+               (if (null? (cdr lst))
+                   (cons (car lst) (car (last-pair args)))
+                   (cons (car lst) (copy (cdr lst))))))))
+
+      (else (apply s7-append args)))))
+
+(unless (defined? 'drop-right)
+  (define (drop-right lst n)
+    (let loop ((lst lst) (result '()))
+      (if (or (null? lst) (null? (cdr lst)))
+          (reverse result)
+          (loop (cdr lst) (cons (car lst) result))))))
+
+(unless (defined? 'last-pair)
+  (define (last-pair lst)
+    (if (null? (cdr lst))
+        lst
+        (last-pair (cdr lst)))))
+
+(define %primitive-read        read)
+(define %primitive-eval        eval)
+(define %primitive-eval-string eval-string)
+(define %primitive-load        load)
+
+(define read        g_goldfish-read)
+(define eval        g_goldfish-eval)
+(define eval-string g_goldfish-eval-string)
+(define load        g_goldfish-load)
+
+(%primitive-load "scheme/psyntax.pp")
+
+(define syntax->datum syntax-object->datum)
+(define datum->syntax datum->syntax-object)
+
+
+
+
+(set! *#readers*
+  (append
+    (list
+      ;; #` (quasisyntax)
+      (cons #\` (lambda (str)
+                  (list 'quasisyntax (read))))
+      ;; #, (unsyntax)
+      (cons #\, (lambda (str)
+                  ;; 检查后面是否跟着 @，即 #,@ (unsyntax-splicing)
+                  (let ((next-char (peek-char)))
+                    (if (eq? next-char #\@)
+                        (begin
+                          (read-char) ;; 消耗掉 @
+                          (list 'unsyntax-splicing (read)))
+                        (list 'unsyntax (read)))))))
+      ;; #' (syntax)
+      ;; NOTE: 不能简单这样写，见下方注释
+      ; (cons #\' (lambda (str)
+      ;             (list 'syntax (read)))))
+    *#readers*))
+
+;; ---------------------------------------------------------
+;; 注意：在 s7 的 *#readers* hook 中，不能简单地对原子符号使用 (read)。
+;; 因为此时 (read) 为了确定一个 symbol 的结束，会预读下一个字符。
+;; 如果 #'foo 紧跟括号，如 (#'foo)，内部的 (read) 会消耗掉那个 ')'，
+;; 导致外层解析器因丢失闭合括号而报错。
+;; 如果不是预期如此，这应当是 s7 的 bug
+;; ---------------------------------------------------------
+
+(define (goldfish-read-syntax-object port)
+  (define (delimiter? c)
+    (or (eof-object? c)
+        (char-whitespace? c)
+        ;; 核心界定符：这些字符标志着一个原子符号的终结
+        ;; 我们必须在读到这些字符之前停止，且绝不能从 port 中消耗它们
+        (case c ((#\( #\) #\[ #\] #\{ #\} #\" #\;) #t) (else #f))))
+
+  ;; 1. 处理前置空格（确保跳过 #' 后的空白）
+  (let skip-ws ()
+    (let ((c (peek-char port)))
+      (if (and (not (eof-object? c)) (char-whitespace? c))
+          (begin (read-char port) (skip-ws)))))
+
+  (let ((next (peek-char port)))
+    (cond
+      ((eof-object? next) next)
+
+      ;; 2. 处理复合结构如 #'(foo)
+      ;; 此时直接调用 read 是安全的，因为 read 遇到配对的 ')' 停止，
+      ;; 指针位置刚好符合预期。
+      ((eq? next #\() (read port))
+
+      ;; 3. 处理原子符号如 #'foo
+      ;; 必须通过 peek-char 手动收集字符。一旦遇到界定符（如 ')'），
+      ;; 立即停止收集并返回。这样指针就精准地停在界定符之前，
+      ;; 从而避免了原生 (read) 误吞界定符导致的语法解析崩溃。
+      (else
+       (let collect ((chars '()))
+         (let ((c (peek-char port)))
+           (if (delimiter? c)
+               (if (null? chars)
+                   #f 
+                   (string->symbol (list->string (reverse chars))))
+               (collect (cons (read-char port) chars)))))))))
+
+;; 注册宏
+;; 注意：s7 *#readers* 调用 hook 时，str 参数包含 '#' 之后的已读内容。
+;; 对于 #'hello，str = "'hello"（s7 已把 'hello 整体读完）。
+;; 对于 #'(foo bar)，str = "'"（s7 看到 '( 就停在 ( 前面）。
+;; 因此对于原子符号必须从 str 提取，不能再从 port 读取。
+(set! *#readers*
+  (cons
+    (cons #\' (lambda (str)
+                (if (> (string-length str) 1)
+                    ;; str = "'hello" => 原子符号，从 str 直接提取
+                    (list 'syntax (string->symbol (substring str 1)))
+                    ;; str = "'" => 后面是复合结构如 (foo)，从 port 读取
+                    (list 'syntax (goldfish-read-syntax-object (current-input-port))))))
+    *#readers*))
+
+(set-expander!
+  (lambda (expr)
+    (sc-expand expr #f '(E) '(E))))
+
+(load "scheme/s7-shim.scm")
+(load "scheme/r7rs-small.scm")
diff --git a/goldfish/scheme/case-lambda.scm b/goldfish/scheme/case-lambda.scm
index c28750868..a27888afd 100644
--- a/goldfish/scheme/case-lambda.scm
+++ b/goldfish/scheme/case-lambda.scm
@@ -1,25 +1,37 @@
-; 0-clause BSD
-; Bill Schottstaedt
-; from S7 source repo: r7rs.scm
-
 (define-library (scheme case-lambda)
-  (export case-lambda)
+  (export case-lambda
+          %case-lambda-dispatch
+          %count-fixed-args)
   (begin
+    (define-syntax case-lambda
+      (syntax-rules ()
+        ((_)
+         (lambda args (error "case-lambda: no matching clause")))
+
+        ((_ (params body0 body1 ...) ...)
+         (lambda args
+           (let ((len (length args)))
+             (%case-lambda-dispatch args len (params body0 body1 ...) ...))))))
+
+    (define-syntax %case-lambda-dispatch
+      (syntax-rules ()
+        ((_ args len)
+         (error "case-lambda: no matching clause for arguments" args))
+
+        ((_ args len ((p ...) b0 b1 ...) . rest)
+         (if (= len (length '(p ...)))
+             (apply (lambda (p ...) b0 b1 ...) args)
+             (%case-lambda-dispatch args len . rest)))
 
-    ;; case-lambda       
-    (define-macro (case-lambda . choices)
-      `(lambda args
-         (case (length args)
-           ,@(map
-               (lambda (choice)
-                 (if (or (symbol? (car choice))
-                         (negative? (length (car choice))))
-                     `(else (apply (lambda ,(car choice) ,@(cdr choice)) args))
-                     `((,(length (car choice))) 
-                       (apply (lambda ,(car choice) ,@(cdr choice)) args))))
-               choices)))
-    ) ;define-macro
+        ((_ args len ((p1 . p2) b0 b1 ...) . rest)
+         (if (>= len (%count-fixed-args (p1 . p2)))
+             (apply (lambda (p1 . p2) b0 b1 ...) args)
+             (%case-lambda-dispatch args len . rest)))
 
-  ) ;begin
-) ;define-library
+        ((_ args len (p b0 b1 ...) . rest)
+         (apply (lambda p b0 b1 ...) args))))
 
+    (define-syntax %count-fixed-args
+      (syntax-rules ()
+        ((_ (p1 . p2)) (+ 1 (%count-fixed-args p2)))
+        ((_ p) 0)))))
diff --git a/goldfish/scheme/complex.scm b/goldfish/scheme/complex.scm
index 287546d66..2b039cfa8 100644
--- a/goldfish/scheme/complex.scm
+++ b/goldfish/scheme/complex.scm
@@ -18,15 +18,14 @@
 ;;; Complex number operations
 
 (define-library (scheme complex)
-  (export make-rectangular
-          make-polar
-          real-part
-          imag-part
-          magnitude
-          angle
+  (export (rename make-rectangular make-rectangular)
+          (rename make-polar       make-polar)
+          (rename real-part        real-part)
+          (rename imag-part        imag-part)
+          (rename magnitude        magnitude)
+          (rename angle            angle)
   ) ;export
-  (import (scheme base))
 ) ;define-library
 
 ;; Note: These functions are implemented in the underlying S7 scheme engine
-;; and are made available through the library export mechanism.
\ No newline at end of file
+;; and are made available through the library export mechanism.
diff --git a/goldfish/scheme/cxr.scm b/goldfish/scheme/cxr.scm
index 18ede81fb..ab9fe2c6d 100644
--- a/goldfish/scheme/cxr.scm
+++ b/goldfish/scheme/cxr.scm
@@ -15,11 +15,7 @@
 ;
 
 (define-library (scheme cxr)
-  (export
+  (re-export
     caaar caadr cadar caddr cdaar cdadr cddar cdddr
     caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
-    cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr
-  ) ;export
-  (begin
-  ) ;begin
-) ;define-library
+    cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr))
diff --git a/goldfish/scheme/eval.scm b/goldfish/scheme/eval.scm
index 04a552408..1ca828af6 100644
--- a/goldfish/scheme/eval.scm
+++ b/goldfish/scheme/eval.scm
@@ -15,18 +15,6 @@
 ;
 
 (define-library (scheme eval)
-  (import (scheme base))
-  (export environment eval)
-  (begin
-
-    (define (environment . import-sets)
-      (let ((env (inlet)))
-        (when (not (null? import-sets))
-          (eval (cons 'import import-sets) env)
-        ) ;when
-        env
-      ) ;let
-    ) ;define
-
-  ) ;begin
+  (export (rename interaction-environment environment))
+  (re-export eval)
 ) ;define-library
diff --git a/goldfish/scheme/file.scm b/goldfish/scheme/file.scm
index a0854e19b..4786e6e77 100644
--- a/goldfish/scheme/file.scm
+++ b/goldfish/scheme/file.scm
@@ -15,18 +15,12 @@
 ;
 
 (define-library (scheme file)
-  (export call-with-input-file call-with-output-file
-          delete-file file-exists?
-          open-binary-input-file open-binary-output-file
-          open-input-file open-output-file
-          with-input-from-file with-output-to-file
-  ) ;export
-  (begin
-
-    (define open-binary-input-file open-input-file)
-
-    (define open-binary-output-file open-output-file)
-
-  ) ;begin
+  (re-export call-with-input-file call-with-output-file
+             delete-file file-exists?
+             open-input-file open-output-file
+             with-input-from-file with-output-to-file
+  )
+  (export (rename open-input-file  open-binary-input-file)
+          (rename open-output-file open-binary-output-file)) ;export
 ) ;define-library
 
diff --git a/goldfish/scheme/inexact.scm b/goldfish/scheme/inexact.scm
index 5b78cadd0..cb3e4db5f 100644
--- a/goldfish/scheme/inexact.scm
+++ b/goldfish/scheme/inexact.scm
@@ -18,6 +18,7 @@
 ; useful with inexact values
 (define-library (scheme inexact)
   (export acos asin atan cos exp finite? infinite? log nan? sin sqrt s7-sqrt tan)
+  (import (scheme internal))
   (begin
 
     (define s7-sqrt sqrt)
diff --git a/goldfish/scheme/psyntax.pp b/goldfish/scheme/psyntax.pp
new file mode 100644
index 000000000..89fc09c1a
--- /dev/null
+++ b/goldfish/scheme/psyntax.pp
@@ -0,0 +1,60732 @@
+;;; psyntax.pp
+;;; automatically generated from psyntax.ss
+;;; Tue 03 Mar 2026 01:52:50 PM CST CST
+;;; see copyright notice in psyntax.ss
+
+((lambda ()
+   (letrec* ((lexical-noexpand-87 '"noexpand")
+             (lexical-make-syntax-object-89
+              (lambda (lexical-expression-553 lexical-wrap-554)
+                (vector 'syntax-object lexical-expression-553 lexical-wrap-554)))
+             (lexical-syntax-object?-90
+              (lambda (lexical-x-555)
+                (if (vector? lexical-x-555)
+                    (if (= (vector-length lexical-x-555) '3)
+                        (eq? (vector-ref lexical-x-555 '0) 'syntax-object)
+                        '#f)
+                    '#f)))
+             (lexical-syntax-object-expression-91
+              (lambda (lexical-x-556) (vector-ref lexical-x-556 '1)))
+             (lexical-syntax-object-wrap-92
+              (lambda (lexical-x-557) (vector-ref lexical-x-557 '2)))
+             (lexical-set-syntax-object-expression!-93
+              (lambda (lexical-x-558 lexical-update-559)
+                (vector-set! lexical-x-558 '1 lexical-update-559)))
+             (lexical-set-syntax-object-wrap!-94
+              (lambda (lexical-x-560 lexical-update-561)
+                (vector-set! lexical-x-560 '2 lexical-update-561)))
+             (lexical-annotation?-158 (lambda (lexical-x-562) '#f))
+             (lexical-top-level-eval-hook-159
+              (lambda (lexical-x-563)
+                (eval (list lexical-noexpand-87 lexical-x-563))))
+             (lexical-local-eval-hook-160
+              (lambda (lexical-x-564)
+                (eval (list lexical-noexpand-87 lexical-x-564))))
+             (lexical-define-top-level-value-hook-161
+              (lambda (lexical-sym-565 lexical-val-566)
+                (lexical-top-level-eval-hook-159
+                 (list 'define lexical-sym-565 (list 'quote lexical-val-566)))))
+             (lexical-error-hook-162
+              (lambda (lexical-who-567 lexical-why-568 lexical-what-569)
+                (error lexical-who-567
+                       '"~a ~s"
+                       lexical-why-568
+                       lexical-what-569)))
+             (lexical-put-cte-hook-163
+              (lambda (lexical-symbol-570 lexical-val-571)
+                ($sc-put-cte lexical-symbol-570 lexical-val-571 '*top*)))
+             (lexical-get-global-definition-hook-164
+              (lambda (lexical-symbol-572)
+                (getprop lexical-symbol-572 '*sc-expander*)))
+             (lexical-put-global-definition-hook-165
+              (lambda (lexical-symbol-573 lexical-x-574)
+                (if (not lexical-x-574)
+                    (remprop lexical-symbol-573 '*sc-expander*)
+                    (putprop lexical-symbol-573 '*sc-expander* lexical-x-574))))
+             (lexical-read-only-binding?-166 (lambda (lexical-symbol-575) '#f))
+             (lexical-get-import-binding-167
+              (lambda (lexical-symbol-576 lexical-token-577)
+                (getprop lexical-symbol-576 lexical-token-577)))
+             (lexical-update-import-binding!-168
+              (lambda (lexical-symbol-578 lexical-token-579 lexical-p-580)
+                ((lambda (lexical-x-581)
+                   (if (not lexical-x-581)
+                       (remprop lexical-symbol-578 lexical-token-579)
+                       (putprop
+                        lexical-symbol-578
+                        lexical-token-579
+                        lexical-x-581)))
+                 (lexical-p-580
+                  (lexical-get-import-binding-167
+                   lexical-symbol-578
+                   lexical-token-579)))))
+             (lexical-generate-id-169
+              ((lambda (lexical-digits-582)
+                 ((lambda (lexical-base-583 lexical-session-key-584)
+                    (letrec* ((lexical-make-digit-585
+                               (lambda (lexical-x-587)
+                                 (string-ref lexical-digits-582 lexical-x-587)))
+                              (lexical-fmt-586
+                               (lambda (lexical-n-588)
+                                 ((letrec ((lexical-fmt-589
+                                            (lambda (lexical-n-590
+                                                     lexical-a-591)
+                                              (if (< lexical-n-590
+                                                     lexical-base-583)
+                                                  (list->string
+                                                   (cons (lexical-make-digit-585
+                                                          lexical-n-590)
+                                                         lexical-a-591))
+                                                  ((lambda (lexical-r-592
+                                                            lexical-rest-593)
+                                                     (lexical-fmt-589
+                                                      lexical-rest-593
+                                                      (cons (lexical-make-digit-585
+                                                             lexical-r-592)
+                                                            lexical-a-591)))
+                                                   (modulo
+                                                    lexical-n-590
+                                                    lexical-base-583)
+                                                   (quotient
+                                                    lexical-n-590
+                                                    lexical-base-583))))))
+                                    lexical-fmt-589)
+                                  lexical-n-588
+                                  '()))))
+                      ((lambda (lexical-n-594)
+                         (lambda (lexical-name-595)
+                           (begin
+                             (set! lexical-n-594 (+ lexical-n-594 '1))
+                             (string->symbol
+                              (string-append
+                               lexical-session-key-584
+                               (lexical-fmt-586 lexical-n-594))))))
+                       '-1)))
+                  (string-length lexical-digits-582)
+                  '"_"))
+               '"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!$%&*/<=>?~_^.+-"))
+             (lexical-built-lambda?-243
+              (lambda (lexical-x-596)
+                (if (pair? lexical-x-596)
+                    (eq? (car lexical-x-596) 'lambda)
+                    '#f)))
+             (lexical-build-sequence-261
+              (lambda (lexical-ae-597 lexical-exps-598)
+                ((letrec ((lexical-loop-599
+                           (lambda (lexical-exps-600)
+                             (if (null? (cdr lexical-exps-600))
+                                 (car lexical-exps-600)
+                                 (if (equal? (car lexical-exps-600) '(void))
+                                     (lexical-loop-599 (cdr lexical-exps-600))
+                                     (cons 'begin lexical-exps-600))))))
+                   lexical-loop-599)
+                 lexical-exps-598)))
+             (lexical-build-letrec-262
+              (lambda (lexical-ae-601
+                       lexical-vars-602
+                       lexical-val-exps-603
+                       lexical-body-exp-604)
+                (if (null? lexical-vars-602)
+                    lexical-body-exp-604
+                    (list 'letrec
+                          (map list lexical-vars-602 lexical-val-exps-603)
+                          lexical-body-exp-604))))
+             (lexical-build-letrec*-263
+              (lambda (lexical-ae-605
+                       lexical-vars-606
+                       lexical-val-exps-607
+                       lexical-body-exp-608)
+                (if (null? lexical-vars-606)
+                    lexical-body-exp-608
+                    (list 'letrec*
+                          (map list lexical-vars-606 lexical-val-exps-607)
+                          lexical-body-exp-608))))
+             (lexical-build-body-264
+              (lambda (lexical-ae-609
+                       lexical-vars-610
+                       lexical-val-exps-611
+                       lexical-body-exp-612)
+                (lexical-build-letrec*-263
+                 lexical-ae-609
+                 lexical-vars-610
+                 lexical-val-exps-611
+                 lexical-body-exp-612)))
+             (lexical-build-top-module-265
+              (lambda (lexical-ae-613
+                       lexical-types-614
+                       lexical-vars-615
+                       lexical-val-exps-616
+                       lexical-body-exp-617)
+                (call-with-values
+                 (lambda ()
+                   ((letrec ((lexical-f-618
+                              (lambda (lexical-types-619 lexical-vars-620)
+                                (if (null? lexical-types-619)
+                                    (values '() '() '())
+                                    ((lambda (lexical-var-621)
+                                       (call-with-values
+                                        (lambda ()
+                                          (lexical-f-618
+                                           (cdr lexical-types-619)
+                                           (cdr lexical-vars-620)))
+                                        (lambda (lexical-vars-622
+                                                 lexical-defns-623
+                                                 lexical-sets-624)
+                                          (if (eq? (car lexical-types-619)
+                                                   'global)
+                                              ((lambda (lexical-x-625)
+                                                 (values
+                                                  (cons lexical-x-625
+                                                        lexical-vars-622)
+                                                  (cons (list 'define
+                                                              lexical-var-621
+                                                              (lexical-chi-void-546))
+                                                        lexical-defns-623)
+                                                  (cons (list 'set!
+                                                              lexical-var-621
+                                                              lexical-x-625)
+                                                        lexical-sets-624)))
+                                               (gensym lexical-var-621))
+                                              (values
+                                               (cons lexical-var-621
+                                                     lexical-vars-622)
+                                               lexical-defns-623
+                                               lexical-sets-624)))))
+                                     (car lexical-vars-620))))))
+                      lexical-f-618)
+                    lexical-types-614
+                    lexical-vars-615))
+                 (lambda (lexical-vars-626 lexical-defns-627 lexical-sets-628)
+                   (if (null? lexical-defns-627)
+                       (lexical-build-letrec-262
+                        lexical-ae-613
+                        lexical-vars-626
+                        lexical-val-exps-616
+                        lexical-body-exp-617)
+                       (lexical-build-sequence-261
+                        '#f
+                        (append
+                         lexical-defns-627
+                         (list (lexical-build-letrec-262
+                                lexical-ae-613
+                                lexical-vars-626
+                                lexical-val-exps-616
+                                (lexical-build-sequence-261
+                                 '#f
+                                 (append
+                                  lexical-sets-628
+                                  (list lexical-body-exp-617))))))))))))
+             (lexical-sanitize-binding-298
+              (lambda (lexical-b-629)
+                (if (procedure? lexical-b-629)
+                    (cons 'macro lexical-b-629)
+                    (if (lexical-binding?-312 lexical-b-629)
+                        (if ((lambda (lexical-t-630)
+                               (if (memv lexical-t-630
+                                         '(core macro macro! deferred))
+                                   (procedure?
+                                    (lexical-binding-value-309 lexical-b-629))
+                                   (if (memv lexical-t-630 '($module))
+                                       (lexical-interface?-479
+                                        (lexical-binding-value-309
+                                         lexical-b-629))
+                                       (if (memv lexical-t-630 '(lexical))
+                                           '#f
+                                           (if (memv lexical-t-630
+                                                     '(global meta-variable))
+                                               (symbol?
+                                                (lexical-binding-value-309
+                                                 lexical-b-629))
+                                               (if (memv lexical-t-630
+                                                         '(syntax))
+                                                   ((lambda (lexical-x-631)
+                                                      (if (pair? lexical-x-631)
+                                                          (if '#f
+                                                              ((lambda (lexical-n-632)
+                                                                 (if (integer?
+                                                                      lexical-n-632)
+                                                                     (if (exact?
+                                                                          lexical-n-632)
+                                                                         (>= lexical-n-632
+                                                                             '0)
+                                                                         '#f)
+                                                                     '#f))
+                                                               (cdr lexical-x-631))
+                                                              '#f)
+                                                          '#f))
+                                                    (lexical-binding-value-309
+                                                     lexical-b-629))
+                                                   (if (memv lexical-t-630
+                                                             '(begin
+                                                                define
+                                                                define-syntax
+                                                                set!
+                                                                $module-key
+                                                                $import
+                                                                eval-when
+                                                                meta))
+                                                       (null? (lexical-binding-value-309
+                                                               lexical-b-629))
+                                                       (if (memv lexical-t-630
+                                                                 '(local-syntax))
+                                                           (boolean?
+                                                            (lexical-binding-value-309
+                                                             lexical-b-629))
+                                                           (if (memv lexical-t-630
+                                                                     '(displaced-lexical))
+                                                               (eq? (lexical-binding-value-309
+                                                                     lexical-b-629)
+                                                                    '#f)
+                                                               '#t)))))))))
+                             (lexical-binding-type-308 lexical-b-629))
+                            lexical-b-629
+                            '#f)
+                        '#f))))
+             (lexical-binding-type-308 car)
+             (lexical-binding-value-309 cdr)
+             (lexical-set-binding-type!-310 set-car!)
+             (lexical-set-binding-value!-311 set-cdr!)
+             (lexical-binding?-312
+              (lambda (lexical-x-633)
+                (if (pair? lexical-x-633) (symbol? (car lexical-x-633)) '#f)))
+             (lexical-extend-env-322
+              (lambda (lexical-label-634 lexical-binding-635 lexical-r-636)
+                (cons (cons lexical-label-634 lexical-binding-635)
+                      lexical-r-636)))
+             (lexical-extend-env*-323
+              (lambda (lexical-labels-637 lexical-bindings-638 lexical-r-639)
+                (if (null? lexical-labels-637)
+                    lexical-r-639
+                    (lexical-extend-env*-323
+                     (cdr lexical-labels-637)
+                     (cdr lexical-bindings-638)
+                     (lexical-extend-env-322
+                      (car lexical-labels-637)
+                      (car lexical-bindings-638)
+                      lexical-r-639)))))
+             (lexical-extend-var-env*-324
+              (lambda (lexical-labels-640 lexical-vars-641 lexical-r-642)
+                (if (null? lexical-labels-640)
+                    lexical-r-642
+                    (lexical-extend-var-env*-324
+                     (cdr lexical-labels-640)
+                     (cdr lexical-vars-641)
+                     (lexical-extend-env-322
+                      (car lexical-labels-640)
+                      (cons 'lexical (car lexical-vars-641))
+                      lexical-r-642)))))
+             (lexical-displaced-lexical?-325
+              (lambda (lexical-id-643 lexical-r-644)
+                ((lambda (lexical-n-645)
+                   (if lexical-n-645
+                       ((lambda (lexical-b-646)
+                          (eq? (lexical-binding-type-308 lexical-b-646)
+                               'displaced-lexical))
+                        (lexical-lookup-328 lexical-n-645 lexical-r-644))
+                       '#f))
+                 (lexical-id-var-name-461 lexical-id-643 '(())))))
+             (lexical-displaced-lexical-error-326
+              (lambda (lexical-id-647)
+                (syntax-error
+                 lexical-id-647
+                 (if (lexical-id-var-name-461 lexical-id-647 '(()))
+                     '"identifier out of context"
+                     '"identifier not visible"))))
+             (lexical-lookup*-327
+              (lambda (lexical-x-648 lexical-r-649)
+                ((lambda (lexical-t-650)
+                   (if lexical-t-650
+                       (cdr lexical-t-650)
+                       (if (symbol? lexical-x-648)
+                           ((lambda (lexical-t-651)
+                              (if lexical-t-651
+                                  lexical-t-651
+                                  (cons 'global lexical-x-648)))
+                            (lexical-get-global-definition-hook-164
+                             lexical-x-648))
+                           '(displaced-lexical . #f))))
+                 (assq lexical-x-648 lexical-r-649))))
+             (lexical-lookup-328
+              (lambda (lexical-x-652 lexical-r-653)
+                (letrec* ((lexical-whack-binding!-654
+                           (lambda (lexical-b-655 lexical-*b-656)
+                             (begin
+                               (lexical-set-binding-type!-310
+                                lexical-b-655
+                                (lexical-binding-type-308 lexical-*b-656))
+                               (lexical-set-binding-value!-311
+                                lexical-b-655
+                                (lexical-binding-value-309 lexical-*b-656))))))
+                  ((lambda (lexical-b-657)
+                     (begin
+                       (if (eq? (lexical-binding-type-308 lexical-b-657)
+                                'deferred)
+                           (lexical-whack-binding!-654
+                            lexical-b-657
+                            (lexical-make-transformer-binding-329
+                             ((lexical-binding-value-309 lexical-b-657))))
+                           (void))
+                       lexical-b-657))
+                   (lexical-lookup*-327 lexical-x-652 lexical-r-653)))))
+             (lexical-make-transformer-binding-329
+              (lambda (lexical-b-658)
+                ((lambda (lexical-t-659)
+                   (if lexical-t-659
+                       lexical-t-659
+                       (syntax-error lexical-b-658 '"invalid transformer")))
+                 (lexical-sanitize-binding-298 lexical-b-658))))
+             (lexical-defer-or-eval-transformer-330
+              (lambda (lexical-eval-660 lexical-x-661)
+                (if (lexical-built-lambda?-243 lexical-x-661)
+                    (cons 'deferred
+                          (lambda () (lexical-eval-660 lexical-x-661)))
+                    (lexical-make-transformer-binding-329
+                     (lexical-eval-660 lexical-x-661)))))
+             (lexical-global-extend-331
+              (lambda (lexical-type-662 lexical-sym-663 lexical-val-664)
+                (lexical-put-cte-hook-163
+                 lexical-sym-663
+                 (cons lexical-type-662 lexical-val-664))))
+             (lexical-nonsymbol-id?-332
+              (lambda (lexical-x-665)
+                (if (lexical-syntax-object?-90 lexical-x-665)
+                    (symbol?
+                     ((lambda (lexical-e-666)
+                        (if (lexical-annotation?-158 lexical-e-666)
+                            (annotation-expression lexical-e-666)
+                            lexical-e-666))
+                      (lexical-syntax-object-expression-91 lexical-x-665)))
+                    '#f)))
+             (lexical-id?-333
+              (lambda (lexical-x-667)
+                (if (symbol? lexical-x-667)
+                    '#t
+                    (if (lexical-syntax-object?-90 lexical-x-667)
+                        (symbol?
+                         ((lambda (lexical-e-668)
+                            (if (lexical-annotation?-158 lexical-e-668)
+                                (annotation-expression lexical-e-668)
+                                lexical-e-668))
+                          (lexical-syntax-object-expression-91 lexical-x-667)))
+                        (if (lexical-annotation?-158 lexical-x-667)
+                            (symbol? (annotation-expression lexical-x-667))
+                            '#f)))))
+             (lexical-id-marks-339
+              (lambda (lexical-id-669)
+                (if (lexical-syntax-object?-90 lexical-id-669)
+                    (lexical-wrap-marks-343
+                     (lexical-syntax-object-wrap-92 lexical-id-669))
+                    (lexical-wrap-marks-343 '((top))))))
+             (lexical-id-subst-340
+              (lambda (lexical-id-670)
+                (if (lexical-syntax-object?-90 lexical-id-670)
+                    (lexical-wrap-subst-344
+                     (lexical-syntax-object-wrap-92 lexical-id-670))
+                    (lexical-wrap-marks-343 '((top))))))
+             (lexical-id-sym-name&marks-341
+              (lambda (lexical-x-671 lexical-w-672)
+                (if (lexical-syntax-object?-90 lexical-x-671)
+                    (values
+                     ((lambda (lexical-e-673)
+                        (if (lexical-annotation?-158 lexical-e-673)
+                            (annotation-expression lexical-e-673)
+                            lexical-e-673))
+                      (lexical-syntax-object-expression-91 lexical-x-671))
+                     (lexical-join-marks-450
+                      (lexical-wrap-marks-343 lexical-w-672)
+                      (lexical-wrap-marks-343
+                       (lexical-syntax-object-wrap-92 lexical-x-671))))
+                    (values
+                     ((lambda (lexical-e-674)
+                        (if (lexical-annotation?-158 lexical-e-674)
+                            (annotation-expression lexical-e-674)
+                            lexical-e-674))
+                      lexical-x-671)
+                     (lexical-wrap-marks-343 lexical-w-672)))))
+             (lexical-make-wrap-342 cons)
+             (lexical-wrap-marks-343 car)
+             (lexical-wrap-subst-344 cdr)
+             (lexical-make-indirect-label-382
+              (lambda (lexical-label-675)
+                (vector 'indirect-label lexical-label-675)))
+             (lexical-indirect-label?-383
+              (lambda (lexical-x-676)
+                (if (vector? lexical-x-676)
+                    (if (= (vector-length lexical-x-676) '2)
+                        (eq? (vector-ref lexical-x-676 '0) 'indirect-label)
+                        '#f)
+                    '#f)))
+             (lexical-indirect-label-label-384
+              (lambda (lexical-x-677) (vector-ref lexical-x-677 '1)))
+             (lexical-set-indirect-label-label!-385
+              (lambda (lexical-x-678 lexical-update-679)
+                (vector-set! lexical-x-678 '1 lexical-update-679)))
+             (lexical-gen-indirect-label-386
+              (lambda ()
+                (lexical-make-indirect-label-382 (lexical-gen-label-389))))
+             (lexical-get-indirect-label-387
+              (lambda (lexical-x-680)
+                (lexical-indirect-label-label-384 lexical-x-680)))
+             (lexical-set-indirect-label!-388
+              (lambda (lexical-x-681 lexical-v-682)
+                (lexical-set-indirect-label-label!-385
+                 lexical-x-681
+                 lexical-v-682)))
+             (lexical-gen-label-389 (lambda () (string '#\i)))
+             (lexical-label?-390
+              (lambda (lexical-x-683)
+                ((lambda (lexical-t-684)
+                   (if lexical-t-684
+                       lexical-t-684
+                       ((lambda (lexical-t-685)
+                          (if lexical-t-685
+                              lexical-t-685
+                              (lexical-indirect-label?-383 lexical-x-683)))
+                        (symbol? lexical-x-683))))
+                 (string? lexical-x-683))))
+             (lexical-gen-labels-391
+              (lambda (lexical-ls-686)
+                (if (null? lexical-ls-686)
+                    '()
+                    (cons (lexical-gen-label-389)
+                          (lexical-gen-labels-391 (cdr lexical-ls-686))))))
+             (lexical-make-ribcage-392
+              (lambda (lexical-symnames-687
+                       lexical-marks-688
+                       lexical-labels-689)
+                (vector
+                 'ribcage
+                 lexical-symnames-687
+                 lexical-marks-688
+                 lexical-labels-689)))
+             (lexical-ribcage?-393
+              (lambda (lexical-x-690)
+                (if (vector? lexical-x-690)
+                    (if (= (vector-length lexical-x-690) '4)
+                        (eq? (vector-ref lexical-x-690 '0) 'ribcage)
+                        '#f)
+                    '#f)))
+             (lexical-ribcage-symnames-394
+              (lambda (lexical-x-691) (vector-ref lexical-x-691 '1)))
+             (lexical-ribcage-marks-395
+              (lambda (lexical-x-692) (vector-ref lexical-x-692 '2)))
+             (lexical-ribcage-labels-396
+              (lambda (lexical-x-693) (vector-ref lexical-x-693 '3)))
+             (lexical-set-ribcage-symnames!-397
+              (lambda (lexical-x-694 lexical-update-695)
+                (vector-set! lexical-x-694 '1 lexical-update-695)))
+             (lexical-set-ribcage-marks!-398
+              (lambda (lexical-x-696 lexical-update-697)
+                (vector-set! lexical-x-696 '2 lexical-update-697)))
+             (lexical-set-ribcage-labels!-399
+              (lambda (lexical-x-698 lexical-update-699)
+                (vector-set! lexical-x-698 '3 lexical-update-699)))
+             (lexical-make-top-ribcage-400
+              (lambda (lexical-key-700 lexical-mutable?-701)
+                (vector 'top-ribcage lexical-key-700 lexical-mutable?-701)))
+             (lexical-top-ribcage?-401
+              (lambda (lexical-x-702)
+                (if (vector? lexical-x-702)
+                    (if (= (vector-length lexical-x-702) '3)
+                        (eq? (vector-ref lexical-x-702 '0) 'top-ribcage)
+                        '#f)
+                    '#f)))
+             (lexical-top-ribcage-key-402
+              (lambda (lexical-x-703) (vector-ref lexical-x-703 '1)))
+             (lexical-top-ribcage-mutable?-403
+              (lambda (lexical-x-704) (vector-ref lexical-x-704 '2)))
+             (lexical-set-top-ribcage-key!-404
+              (lambda (lexical-x-705 lexical-update-706)
+                (vector-set! lexical-x-705 '1 lexical-update-706)))
+             (lexical-set-top-ribcage-mutable?!-405
+              (lambda (lexical-x-707 lexical-update-708)
+                (vector-set! lexical-x-707 '2 lexical-update-708)))
+             (lexical-make-import-interface-406
+              (lambda (lexical-interface-709 lexical-new-marks-710)
+                (vector
+                 'import-interface
+                 lexical-interface-709
+                 lexical-new-marks-710)))
+             (lexical-import-interface?-407
+              (lambda (lexical-x-711)
+                (if (vector? lexical-x-711)
+                    (if (= (vector-length lexical-x-711) '3)
+                        (eq? (vector-ref lexical-x-711 '0) 'import-interface)
+                        '#f)
+                    '#f)))
+             (lexical-import-interface-interface-408
+              (lambda (lexical-x-712) (vector-ref lexical-x-712 '1)))
+             (lexical-import-interface-new-marks-409
+              (lambda (lexical-x-713) (vector-ref lexical-x-713 '2)))
+             (lexical-set-import-interface-interface!-410
+              (lambda (lexical-x-714 lexical-update-715)
+                (vector-set! lexical-x-714 '1 lexical-update-715)))
+             (lexical-set-import-interface-new-marks!-411
+              (lambda (lexical-x-716 lexical-update-717)
+                (vector-set! lexical-x-716 '2 lexical-update-717)))
+             (lexical-make-env-412
+              (lambda (lexical-top-ribcage-718 lexical-wrap-719)
+                (vector 'env lexical-top-ribcage-718 lexical-wrap-719)))
+             (lexical-env?-413
+              (lambda (lexical-x-720)
+                (if (vector? lexical-x-720)
+                    (if (= (vector-length lexical-x-720) '3)
+                        (eq? (vector-ref lexical-x-720 '0) 'env)
+                        '#f)
+                    '#f)))
+             (lexical-env-top-ribcage-414
+              (lambda (lexical-x-721) (vector-ref lexical-x-721 '1)))
+             (lexical-env-wrap-415
+              (lambda (lexical-x-722) (vector-ref lexical-x-722 '2)))
+             (lexical-set-env-top-ribcage!-416
+              (lambda (lexical-x-723 lexical-update-724)
+                (vector-set! lexical-x-723 '1 lexical-update-724)))
+             (lexical-set-env-wrap!-417
+              (lambda (lexical-x-725 lexical-update-726)
+                (vector-set! lexical-x-725 '2 lexical-update-726)))
+             (lexical-anti-mark-427
+              (lambda (lexical-w-727)
+                (lexical-make-wrap-342
+                 (cons '#f (lexical-wrap-marks-343 lexical-w-727))
+                 (cons 'shift (lexical-wrap-subst-344 lexical-w-727)))))
+             (lexical-barrier-marker-432 '#f)
+             (lexical-extend-ribcage!-437
+              (lambda (lexical-ribcage-728 lexical-id-729 lexical-label-730)
+                (begin
+                  (lexical-set-ribcage-symnames!-397
+                   lexical-ribcage-728
+                   (cons ((lambda (lexical-e-731)
+                            (if (lexical-annotation?-158 lexical-e-731)
+                                (annotation-expression lexical-e-731)
+                                lexical-e-731))
+                          (lexical-syntax-object-expression-91 lexical-id-729))
+                         (lexical-ribcage-symnames-394 lexical-ribcage-728)))
+                  (lexical-set-ribcage-marks!-398
+                   lexical-ribcage-728
+                   (cons (lexical-wrap-marks-343
+                          (lexical-syntax-object-wrap-92 lexical-id-729))
+                         (lexical-ribcage-marks-395 lexical-ribcage-728)))
+                  (lexical-set-ribcage-labels!-399
+                   lexical-ribcage-728
+                   (cons lexical-label-730
+                         (lexical-ribcage-labels-396 lexical-ribcage-728))))))
+             (lexical-import-extend-ribcage!-438
+              (lambda (lexical-ribcage-732
+                       lexical-new-marks-733
+                       lexical-id-734
+                       lexical-label-735)
+                (begin
+                  (lexical-set-ribcage-symnames!-397
+                   lexical-ribcage-732
+                   (cons ((lambda (lexical-e-736)
+                            (if (lexical-annotation?-158 lexical-e-736)
+                                (annotation-expression lexical-e-736)
+                                lexical-e-736))
+                          (lexical-syntax-object-expression-91 lexical-id-734))
+                         (lexical-ribcage-symnames-394 lexical-ribcage-732)))
+                  (lexical-set-ribcage-marks!-398
+                   lexical-ribcage-732
+                   (cons (lexical-join-marks-450
+                          lexical-new-marks-733
+                          (lexical-wrap-marks-343
+                           (lexical-syntax-object-wrap-92 lexical-id-734)))
+                         (lexical-ribcage-marks-395 lexical-ribcage-732)))
+                  (lexical-set-ribcage-labels!-399
+                   lexical-ribcage-732
+                   (cons lexical-label-735
+                         (lexical-ribcage-labels-396 lexical-ribcage-732))))))
+             (lexical-extend-ribcage-barrier!-439
+              (lambda (lexical-ribcage-737 lexical-killer-id-738)
+                (lexical-extend-ribcage-barrier-help!-440
+                 lexical-ribcage-737
+                 (lexical-syntax-object-wrap-92 lexical-killer-id-738))))
+             (lexical-extend-ribcage-barrier-help!-440
+              (lambda (lexical-ribcage-739 lexical-wrap-740)
+                (begin
+                  (lexical-set-ribcage-symnames!-397
+                   lexical-ribcage-739
+                   (cons lexical-barrier-marker-432
+                         (lexical-ribcage-symnames-394 lexical-ribcage-739)))
+                  (lexical-set-ribcage-marks!-398
+                   lexical-ribcage-739
+                   (cons (lexical-wrap-marks-343 lexical-wrap-740)
+                         (lexical-ribcage-marks-395 lexical-ribcage-739))))))
+             (lexical-extend-ribcage-subst!-441
+              (lambda (lexical-ribcage-741 lexical-import-iface-742)
+                (lexical-set-ribcage-symnames!-397
+                 lexical-ribcage-741
+                 (cons lexical-import-iface-742
+                       (lexical-ribcage-symnames-394 lexical-ribcage-741)))))
+             (lexical-lookup-import-binding-name-442
+              (lambda (lexical-sym-743
+                       lexical-marks-744
+                       lexical-token-745
+                       lexical-new-marks-746)
+                ((lambda (lexical-new-747)
+                   (if lexical-new-747
+                       ((letrec ((lexical-f-748
+                                  (lambda (lexical-new-749)
+                                    (if (pair? lexical-new-749)
+                                        ((lambda (lexical-t-750)
+                                           (if lexical-t-750
+                                               lexical-t-750
+                                               (lexical-f-748
+                                                (cdr lexical-new-749))))
+                                         (lexical-f-748 (car lexical-new-749)))
+                                        (if (symbol? lexical-new-749)
+                                            (if (lexical-same-marks?-452
+                                                 lexical-marks-744
+                                                 (lexical-join-marks-450
+                                                  lexical-new-marks-746
+                                                  (lexical-wrap-marks-343
+                                                   '((top)))))
+                                                lexical-new-749
+                                                '#f)
+                                            (if (lexical-same-marks?-452
+                                                 lexical-marks-744
+                                                 (lexical-join-marks-450
+                                                  lexical-new-marks-746
+                                                  (lexical-wrap-marks-343
+                                                   (lexical-syntax-object-wrap-92
+                                                    lexical-new-749))))
+                                                lexical-new-749
+                                                '#f))))))
+                          lexical-f-748)
+                        lexical-new-747)
+                       '#f))
+                 (lexical-get-import-binding-167
+                  lexical-sym-743
+                  lexical-token-745))))
+             (lexical-store-import-binding-443
+              (lambda (lexical-id-751 lexical-token-752 lexical-new-marks-753)
+                (letrec* ((lexical-cons-id-754
+                           (lambda (lexical-id-756 lexical-x-757)
+                             (if (not lexical-x-757)
+                                 lexical-id-756
+                                 (cons lexical-id-756 lexical-x-757))))
+                          (lexical-weed-755
+                           (lambda (lexical-marks-758 lexical-x-759)
+                             (if (pair? lexical-x-759)
+                                 (if (lexical-same-marks?-452
+                                      (lexical-id-marks-339
+                                       (car lexical-x-759))
+                                      lexical-marks-758)
+                                     (lexical-weed-755
+                                      lexical-marks-758
+                                      (cdr lexical-x-759))
+                                     (lexical-cons-id-754
+                                      (car lexical-x-759)
+                                      (lexical-weed-755
+                                       lexical-marks-758
+                                       (cdr lexical-x-759))))
+                                 (if lexical-x-759
+                                     (if (not (lexical-same-marks?-452
+                                               (lexical-id-marks-339
+                                                lexical-x-759)
+                                               lexical-marks-758))
+                                         lexical-x-759
+                                         '#f)
+                                     '#f)))))
+                  ((lambda (lexical-id-760)
+                     ((lambda (lexical-sym-761)
+                        (if (not (eq? lexical-id-760 lexical-sym-761))
+                            ((lambda (lexical-marks-762)
+                               (lexical-update-import-binding!-168
+                                lexical-sym-761
+                                lexical-token-752
+                                (lambda (lexical-old-binding-763)
+                                  ((lambda (lexical-x-764)
+                                     (lexical-cons-id-754
+                                      (if (lexical-same-marks?-452
+                                           lexical-marks-762
+                                           (lexical-wrap-marks-343 '((top))))
+                                          (lexical-resolved-id-var-name-447
+                                           lexical-id-760)
+                                          lexical-id-760)
+                                      lexical-x-764))
+                                   (lexical-weed-755
+                                    lexical-marks-762
+                                    lexical-old-binding-763)))))
+                             (lexical-id-marks-339 lexical-id-760))
+                            (void)))
+                      ((lambda (lexical-x-765)
+                         ((lambda (lexical-e-766)
+                            (if (lexical-annotation?-158 lexical-e-766)
+                                (annotation-expression lexical-e-766)
+                                lexical-e-766))
+                          (if (lexical-syntax-object?-90 lexical-x-765)
+                              (lexical-syntax-object-expression-91
+                               lexical-x-765)
+                              lexical-x-765)))
+                       lexical-id-760)))
+                   (if (null? lexical-new-marks-753)
+                       lexical-id-751
+                       (lexical-make-syntax-object-89
+                        ((lambda (lexical-x-767)
+                           ((lambda (lexical-e-768)
+                              (if (lexical-annotation?-158 lexical-e-768)
+                                  (annotation-expression lexical-e-768)
+                                  lexical-e-768))
+                            (if (lexical-syntax-object?-90 lexical-x-767)
+                                (lexical-syntax-object-expression-91
+                                 lexical-x-767)
+                                lexical-x-767)))
+                         lexical-id-751)
+                        (lexical-make-wrap-342
+                         (lexical-join-marks-450
+                          lexical-new-marks-753
+                          (lexical-id-marks-339 lexical-id-751))
+                         (lexical-id-subst-340 lexical-id-751))))))))
+             (lexical-make-binding-wrap-444
+              (lambda (lexical-ids-769 lexical-labels-770 lexical-w-771)
+                (if (null? lexical-ids-769)
+                    lexical-w-771
+                    (lexical-make-wrap-342
+                     (lexical-wrap-marks-343 lexical-w-771)
+                     (cons ((lambda (lexical-labelvec-772)
+                              ((lambda (lexical-n-773)
+                                 ((lambda (lexical-symnamevec-774
+                                           lexical-marksvec-775)
+                                    (begin
+                                      ((letrec ((lexical-f-776
+                                                 (lambda (lexical-ids-777
+                                                          lexical-i-778)
+                                                   (if (not (null? lexical-ids-777))
+                                                       (call-with-values
+                                                        (lambda ()
+                                                          (lexical-id-sym-name&marks-341
+                                                           (car lexical-ids-777)
+                                                           lexical-w-771))
+                                                        (lambda (lexical-symname-779
+                                                                 lexical-marks-780)
+                                                          (begin
+                                                            (vector-set!
+                                                             lexical-symnamevec-774
+                                                             lexical-i-778
+                                                             lexical-symname-779)
+                                                            (vector-set!
+                                                             lexical-marksvec-775
+                                                             lexical-i-778
+                                                             lexical-marks-780)
+                                                            (lexical-f-776
+                                                             (cdr lexical-ids-777)
+                                                             (+ lexical-i-778
+                                                                '1)))))
+                                                       (void)))))
+                                         lexical-f-776)
+                                       lexical-ids-769
+                                       '0)
+                                      (lexical-make-ribcage-392
+                                       lexical-symnamevec-774
+                                       lexical-marksvec-775
+                                       lexical-labelvec-772)))
+                                  (make-vector lexical-n-773)
+                                  (make-vector lexical-n-773)))
+                               (vector-length lexical-labelvec-772)))
+                            (list->vector lexical-labels-770))
+                           (lexical-wrap-subst-344 lexical-w-771))))))
+             (lexical-make-resolved-id-445
+              (lambda (lexical-fromsym-781 lexical-marks-782 lexical-tosym-783)
+                (lexical-make-syntax-object-89
+                 lexical-fromsym-781
+                 (lexical-make-wrap-342
+                  lexical-marks-782
+                  (list (lexical-make-ribcage-392
+                         (vector lexical-fromsym-781)
+                         (vector lexical-marks-782)
+                         (vector lexical-tosym-783)))))))
+             (lexical-id->resolved-id-446
+              (lambda (lexical-id-784)
+                (call-with-values
+                 (lambda ()
+                   (lexical-id-var-name&marks-459 lexical-id-784 '(())))
+                 (lambda (lexical-tosym-785 lexical-marks-786)
+                   (begin
+                     (if (not lexical-tosym-785)
+                         (syntax-error
+                          lexical-id-784
+                          '"identifier not visible for export")
+                         (void))
+                     (lexical-make-resolved-id-445
+                      ((lambda (lexical-x-787)
+                         ((lambda (lexical-e-788)
+                            (if (lexical-annotation?-158 lexical-e-788)
+                                (annotation-expression lexical-e-788)
+                                lexical-e-788))
+                          (if (lexical-syntax-object?-90 lexical-x-787)
+                              (lexical-syntax-object-expression-91
+                               lexical-x-787)
+                              lexical-x-787)))
+                       lexical-id-784)
+                      lexical-marks-786
+                      lexical-tosym-785))))))
+             (lexical-resolved-id-var-name-447
+              (lambda (lexical-id-789)
+                (vector-ref
+                 (lexical-ribcage-labels-396
+                  (car (lexical-wrap-subst-344
+                        (lexical-syntax-object-wrap-92 lexical-id-789))))
+                 '0)))
+             (lexical-smart-append-448
+              (lambda (lexical-m1-790 lexical-m2-791)
+                (if (null? lexical-m2-791)
+                    lexical-m1-790
+                    (append lexical-m1-790 lexical-m2-791))))
+             (lexical-join-wraps-449
+              (lambda (lexical-w1-792 lexical-w2-793)
+                ((lambda (lexical-m1-794 lexical-s1-795)
+                   (if (null? lexical-m1-794)
+                       (if (null? lexical-s1-795)
+                           lexical-w2-793
+                           (lexical-make-wrap-342
+                            (lexical-wrap-marks-343 lexical-w2-793)
+                            (lexical-join-subst-451
+                             lexical-s1-795
+                             (lexical-wrap-subst-344 lexical-w2-793))))
+                       (lexical-make-wrap-342
+                        (lexical-join-marks-450
+                         lexical-m1-794
+                         (lexical-wrap-marks-343 lexical-w2-793))
+                        (lexical-join-subst-451
+                         lexical-s1-795
+                         (lexical-wrap-subst-344 lexical-w2-793)))))
+                 (lexical-wrap-marks-343 lexical-w1-792)
+                 (lexical-wrap-subst-344 lexical-w1-792))))
+             (lexical-join-marks-450
+              (lambda (lexical-m1-796 lexical-m2-797)
+                (lexical-smart-append-448 lexical-m1-796 lexical-m2-797)))
+             (lexical-join-subst-451
+              (lambda (lexical-s1-798 lexical-s2-799)
+                (lexical-smart-append-448 lexical-s1-798 lexical-s2-799)))
+             (lexical-same-marks?-452
+              (lambda (lexical-x-800 lexical-y-801)
+                ((lambda (lexical-t-802)
+                   (if lexical-t-802
+                       lexical-t-802
+                       (if (not (null? lexical-x-800))
+                           (if (not (null? lexical-y-801))
+                               (if (eq? (car lexical-x-800)
+                                        (car lexical-y-801))
+                                   (lexical-same-marks?-452
+                                    (cdr lexical-x-800)
+                                    (cdr lexical-y-801))
+                                   '#f)
+                               '#f)
+                           '#f)))
+                 (eq? lexical-x-800 lexical-y-801))))
+             (lexical-diff-marks-453
+              (lambda (lexical-m1-803 lexical-m2-804)
+                ((lambda (lexical-n1-805 lexical-n2-806)
+                   ((letrec ((lexical-f-807
+                              (lambda (lexical-n1-808 lexical-m1-809)
+                                (if (> lexical-n1-808 lexical-n2-806)
+                                    (cons (car lexical-m1-809)
+                                          (lexical-f-807
+                                           (- lexical-n1-808 '1)
+                                           (cdr lexical-m1-809)))
+                                    (if (equal? lexical-m1-809 lexical-m2-804)
+                                        '()
+                                        (error 'sc-expand
+                                               '"internal error in diff-marks: ~s is not a tail of ~s"
+                                               lexical-m1-809
+                                               lexical-m2-804))))))
+                      lexical-f-807)
+                    lexical-n1-805
+                    lexical-m1-803))
+                 (length lexical-m1-803)
+                 (length lexical-m2-804))))
+             (lexical-leave-implicit?-454
+              (lambda (lexical-token-810) (eq? lexical-token-810 '*top*)))
+             (lexical-new-binding-455
+              (lambda (lexical-sym-811 lexical-marks-812 lexical-token-813)
+                ((lambda (lexical-loc-814)
+                   ((lambda (lexical-id-815)
+                      (begin
+                        (lexical-store-import-binding-443
+                         lexical-id-815
+                         lexical-token-813
+                         '())
+                        (values lexical-loc-814 lexical-id-815)))
+                    (lexical-make-resolved-id-445
+                     lexical-sym-811
+                     lexical-marks-812
+                     lexical-loc-814)))
+                 (if (if (lexical-leave-implicit?-454 lexical-token-813)
+                         (lexical-same-marks?-452
+                          lexical-marks-812
+                          (lexical-wrap-marks-343 '((top))))
+                         '#f)
+                     lexical-sym-811
+                     (lexical-generate-id-169 lexical-sym-811)))))
+             (lexical-top-id-bound-var-name-456
+              (lambda (lexical-sym-816
+                       lexical-marks-817
+                       lexical-top-ribcage-818)
+                ((lambda (lexical-token-819)
+                   ((lambda (lexical-t-820)
+                      (if lexical-t-820
+                          ((lambda (lexical-id-821)
+                             (if (symbol? lexical-id-821)
+                                 (if (lexical-read-only-binding?-166
+                                      lexical-id-821)
+                                     (lexical-new-binding-455
+                                      lexical-sym-816
+                                      lexical-marks-817
+                                      lexical-token-819)
+                                     (values
+                                      lexical-id-821
+                                      (lexical-make-resolved-id-445
+                                       lexical-sym-816
+                                       lexical-marks-817
+                                       lexical-id-821)))
+                                 (values
+                                  (lexical-resolved-id-var-name-447
+                                   lexical-id-821)
+                                  lexical-id-821)))
+                           lexical-t-820)
+                          (lexical-new-binding-455
+                           lexical-sym-816
+                           lexical-marks-817
+                           lexical-token-819)))
+                    (lexical-lookup-import-binding-name-442
+                     lexical-sym-816
+                     lexical-marks-817
+                     lexical-token-819
+                     '())))
+                 (lexical-top-ribcage-key-402 lexical-top-ribcage-818))))
+             (lexical-top-id-free-var-name-457
+              (lambda (lexical-sym-822
+                       lexical-marks-823
+                       lexical-top-ribcage-824)
+                ((lambda (lexical-token-825)
+                   ((lambda (lexical-t-826)
+                      (if lexical-t-826
+                          ((lambda (lexical-id-827)
+                             (if (symbol? lexical-id-827)
+                                 lexical-id-827
+                                 (lexical-resolved-id-var-name-447
+                                  lexical-id-827)))
+                           lexical-t-826)
+                          (if (if (lexical-top-ribcage-mutable?-403
+                                   lexical-top-ribcage-824)
+                                  (lexical-same-marks?-452
+                                   lexical-marks-823
+                                   (lexical-wrap-marks-343 '((top))))
+                                  '#f)
+                              (call-with-values
+                               (lambda ()
+                                 (lexical-new-binding-455
+                                  lexical-sym-822
+                                  (lexical-wrap-marks-343 '((top)))
+                                  lexical-token-825))
+                               (lambda (lexical-sym-828 lexical-id-829)
+                                 lexical-sym-828))
+                              '#f)))
+                    (lexical-lookup-import-binding-name-442
+                     lexical-sym-822
+                     lexical-marks-823
+                     lexical-token-825
+                     '())))
+                 (lexical-top-ribcage-key-402 lexical-top-ribcage-824))))
+             (lexical-id-var-name-loc&marks-458
+              (lambda (lexical-id-830 lexical-w-831)
+                (letrec* ((lexical-search-832
+                           (lambda (lexical-sym-835
+                                    lexical-subst-836
+                                    lexical-marks-837)
+                             (if (null? lexical-subst-836)
+                                 (values '#f lexical-marks-837)
+                                 ((lambda (lexical-fst-838)
+                                    (if (eq? lexical-fst-838 'shift)
+                                        (lexical-search-832
+                                         lexical-sym-835
+                                         (cdr lexical-subst-836)
+                                         (cdr lexical-marks-837))
+                                        (if (lexical-ribcage?-393
+                                             lexical-fst-838)
+                                            ((lambda (lexical-symnames-839)
+                                               (if (vector?
+                                                    lexical-symnames-839)
+                                                   (lexical-search-vector-rib-834
+                                                    lexical-sym-835
+                                                    lexical-subst-836
+                                                    lexical-marks-837
+                                                    lexical-symnames-839
+                                                    lexical-fst-838)
+                                                   (lexical-search-list-rib-833
+                                                    lexical-sym-835
+                                                    lexical-subst-836
+                                                    lexical-marks-837
+                                                    lexical-symnames-839
+                                                    lexical-fst-838)))
+                                             (lexical-ribcage-symnames-394
+                                              lexical-fst-838))
+                                            (if (lexical-top-ribcage?-401
+                                                 lexical-fst-838)
+                                                ((lambda (lexical-t-840)
+                                                   (if lexical-t-840
+                                                       ((lambda (lexical-var-name-841)
+                                                          (values
+                                                           lexical-var-name-841
+                                                           lexical-marks-837))
+                                                        lexical-t-840)
+                                                       (lexical-search-832
+                                                        lexical-sym-835
+                                                        (cdr lexical-subst-836)
+                                                        lexical-marks-837)))
+                                                 (lexical-top-id-free-var-name-457
+                                                  lexical-sym-835
+                                                  lexical-marks-837
+                                                  lexical-fst-838))
+                                                (error 'sc-expand
+                                                       '"internal error in id-var-name-loc&marks: improper subst ~s"
+                                                       lexical-subst-836)))))
+                                  (car lexical-subst-836)))))
+                          (lexical-search-list-rib-833
+                           (lambda (lexical-sym-842
+                                    lexical-subst-843
+                                    lexical-marks-844
+                                    lexical-symnames-845
+                                    lexical-ribcage-846)
+                             ((letrec ((lexical-f-847
+                                        (lambda (lexical-symnames-848
+                                                 lexical-i-849)
+                                          (if (null? lexical-symnames-848)
+                                              (lexical-search-832
+                                               lexical-sym-842
+                                               (cdr lexical-subst-843)
+                                               lexical-marks-844)
+                                              ((lambda (lexical-x-850)
+                                                 (if (if (eq? lexical-x-850
+                                                              lexical-sym-842)
+                                                         (lexical-same-marks?-452
+                                                          lexical-marks-844
+                                                          (list-ref
+                                                           (lexical-ribcage-marks-395
+                                                            lexical-ribcage-846)
+                                                           lexical-i-849))
+                                                         '#f)
+                                                     (values
+                                                      (list-ref
+                                                       (lexical-ribcage-labels-396
+                                                        lexical-ribcage-846)
+                                                       lexical-i-849)
+                                                      lexical-marks-844)
+                                                     (if (lexical-import-interface?-407
+                                                          lexical-x-850)
+                                                         ((lambda (lexical-iface-851
+                                                                   lexical-new-marks-852)
+                                                            ((lambda (lexical-t-853)
+                                                               (if lexical-t-853
+                                                                   ((lambda (lexical-token-854)
+                                                                      ((lambda (lexical-t-855)
+                                                                         (if lexical-t-855
+                                                                             ((lambda (lexical-id-856)
+                                                                                (values
+                                                                                 (if (symbol?
+                                                                                      lexical-id-856)
+                                                                                     lexical-id-856
+                                                                                     (lexical-resolved-id-var-name-447
+                                                                                      lexical-id-856))
+                                                                                 lexical-marks-844))
+                                                                              lexical-t-855)
+                                                                             (lexical-f-847
+                                                                              (cdr lexical-symnames-848)
+                                                                              lexical-i-849)))
+                                                                       (lexical-lookup-import-binding-name-442
+                                                                        lexical-sym-842
+                                                                        lexical-marks-844
+                                                                        lexical-token-854
+                                                                        lexical-new-marks-852)))
+                                                                    lexical-t-853)
+                                                                   ((lambda (lexical-ie-857)
+                                                                      ((lambda (lexical-n-858)
+                                                                         ((lambda ()
+                                                                            ((letrec ((lexical-g-859
+                                                                                       (lambda (lexical-j-860)
+                                                                                         (if (= lexical-j-860
+                                                                                                lexical-n-858)
+                                                                                             (lexical-f-847
+                                                                                              (cdr lexical-symnames-848)
+                                                                                              lexical-i-849)
+                                                                                             ((lambda (lexical-id-861)
+                                                                                                ((lambda (lexical-id.sym-862
+                                                                                                          lexical-id.marks-863)
+                                                                                                   (if (lexical-help-bound-id=?-464
+                                                                                                        lexical-id.sym-862
+                                                                                                        lexical-id.marks-863
+                                                                                                        lexical-sym-842
+                                                                                                        lexical-marks-844)
+                                                                                                       (values
+                                                                                                        (lexical-lookup-import-label-534
+                                                                                                         lexical-id-861)
+                                                                                                        lexical-marks-844)
+                                                                                                       (lexical-g-859
+                                                                                                        (+ lexical-j-860
+                                                                                                           '1))))
+                                                                                                 ((lambda (lexical-x-864)
+                                                                                                    ((lambda (lexical-e-865)
+                                                                                                       (if (lexical-annotation?-158
+                                                                                                            lexical-e-865)
+                                                                                                           (annotation-expression
+                                                                                                            lexical-e-865)
+                                                                                                           lexical-e-865))
+                                                                                                     (if (lexical-syntax-object?-90
+                                                                                                          lexical-x-864)
+                                                                                                         (lexical-syntax-object-expression-91
+                                                                                                          lexical-x-864)
+                                                                                                         lexical-x-864)))
+                                                                                                  lexical-id-861)
+                                                                                                 (lexical-join-marks-450
+                                                                                                  lexical-new-marks-852
+                                                                                                  (lexical-id-marks-339
+                                                                                                   lexical-id-861))))
+                                                                                              (vector-ref
+                                                                                               lexical-ie-857
+                                                                                               lexical-j-860))))))
+                                                                               lexical-g-859)
+                                                                             '0))))
+                                                                       (vector-length
+                                                                        lexical-ie-857)))
+                                                                    (lexical-interface-exports-481
+                                                                     lexical-iface-851))))
+                                                             (lexical-interface-token-482
+                                                              lexical-iface-851)))
+                                                          (lexical-import-interface-interface-408
+                                                           lexical-x-850)
+                                                          (lexical-import-interface-new-marks-409
+                                                           lexical-x-850))
+                                                         (if (if (eq? lexical-x-850
+                                                                      lexical-barrier-marker-432)
+                                                                 (lexical-same-marks?-452
+                                                                  lexical-marks-844
+                                                                  (list-ref
+                                                                   (lexical-ribcage-marks-395
+                                                                    lexical-ribcage-846)
+                                                                   lexical-i-849))
+                                                                 '#f)
+                                                             (values
+                                                              '#f
+                                                              lexical-marks-844)
+                                                             (lexical-f-847
+                                                              (cdr lexical-symnames-848)
+                                                              (+ lexical-i-849
+                                                                 '1))))))
+                                               (car lexical-symnames-848))))))
+                                lexical-f-847)
+                              lexical-symnames-845
+                              '0)))
+                          (lexical-search-vector-rib-834
+                           (lambda (lexical-sym-866
+                                    lexical-subst-867
+                                    lexical-marks-868
+                                    lexical-symnames-869
+                                    lexical-ribcage-870)
+                             ((lambda (lexical-n-871)
+                                ((letrec ((lexical-f-872
+                                           (lambda (lexical-i-873)
+                                             (if (= lexical-i-873
+                                                    lexical-n-871)
+                                                 (lexical-search-832
+                                                  lexical-sym-866
+                                                  (cdr lexical-subst-867)
+                                                  lexical-marks-868)
+                                                 (if (if (eq? (vector-ref
+                                                               lexical-symnames-869
+                                                               lexical-i-873)
+                                                              lexical-sym-866)
+                                                         (lexical-same-marks?-452
+                                                          lexical-marks-868
+                                                          (vector-ref
+                                                           (lexical-ribcage-marks-395
+                                                            lexical-ribcage-870)
+                                                           lexical-i-873))
+                                                         '#f)
+                                                     (values
+                                                      (vector-ref
+                                                       (lexical-ribcage-labels-396
+                                                        lexical-ribcage-870)
+                                                       lexical-i-873)
+                                                      lexical-marks-868)
+                                                     (lexical-f-872
+                                                      (+ lexical-i-873 '1)))))))
+                                   lexical-f-872)
+                                 '0))
+                              (vector-length lexical-symnames-869)))))
+                  (if (symbol? lexical-id-830)
+                      (lexical-search-832
+                       lexical-id-830
+                       (lexical-wrap-subst-344 lexical-w-831)
+                       (lexical-wrap-marks-343 lexical-w-831))
+                      (if (lexical-syntax-object?-90 lexical-id-830)
+                          ((lambda (lexical-sym-874 lexical-w1-875)
+                             (call-with-values
+                              (lambda ()
+                                (lexical-search-832
+                                 lexical-sym-874
+                                 (lexical-wrap-subst-344 lexical-w-831)
+                                 (lexical-join-marks-450
+                                  (lexical-wrap-marks-343 lexical-w-831)
+                                  (lexical-wrap-marks-343 lexical-w1-875))))
+                              (lambda (lexical-name-876 lexical-marks-877)
+                                (if lexical-name-876
+                                    (values lexical-name-876 lexical-marks-877)
+                                    (lexical-search-832
+                                     lexical-sym-874
+                                     (lexical-wrap-subst-344 lexical-w1-875)
+                                     lexical-marks-877)))))
+                           ((lambda (lexical-e-878)
+                              (if (lexical-annotation?-158 lexical-e-878)
+                                  (annotation-expression lexical-e-878)
+                                  lexical-e-878))
+                            (lexical-syntax-object-expression-91
+                             lexical-id-830))
+                           (lexical-syntax-object-wrap-92 lexical-id-830))
+                          (if (lexical-annotation?-158 lexical-id-830)
+                              (lexical-search-832
+                               ((lambda (lexical-e-879)
+                                  (if (lexical-annotation?-158 lexical-e-879)
+                                      (annotation-expression lexical-e-879)
+                                      lexical-e-879))
+                                lexical-id-830)
+                               (lexical-wrap-subst-344 lexical-w-831)
+                               (lexical-wrap-marks-343 lexical-w-831))
+                              (lexical-error-hook-162
+                               'id-var-name
+                               '"invalid id"
+                               lexical-id-830)))))))
+             (lexical-id-var-name&marks-459
+              (lambda (lexical-id-880 lexical-w-881)
+                (call-with-values
+                 (lambda ()
+                   (lexical-id-var-name-loc&marks-458
+                    lexical-id-880
+                    lexical-w-881))
+                 (lambda (lexical-label-882 lexical-marks-883)
+                   (values
+                    (if (lexical-indirect-label?-383 lexical-label-882)
+                        (lexical-get-indirect-label-387 lexical-label-882)
+                        lexical-label-882)
+                    lexical-marks-883)))))
+             (lexical-id-var-name-loc-460
+              (lambda (lexical-id-884 lexical-w-885)
+                (call-with-values
+                 (lambda ()
+                   (lexical-id-var-name-loc&marks-458
+                    lexical-id-884
+                    lexical-w-885))
+                 (lambda (lexical-label-886 lexical-marks-887)
+                   lexical-label-886))))
+             (lexical-id-var-name-461
+              (lambda (lexical-id-888 lexical-w-889)
+                (call-with-values
+                 (lambda ()
+                   (lexical-id-var-name-loc&marks-458
+                    lexical-id-888
+                    lexical-w-889))
+                 (lambda (lexical-label-890 lexical-marks-891)
+                   (if (lexical-indirect-label?-383 lexical-label-890)
+                       (lexical-get-indirect-label-387 lexical-label-890)
+                       lexical-label-890)))))
+             (lexical-free-id=?-462
+              (lambda (lexical-i-892 lexical-j-893)
+                (if (eq? ((lambda (lexical-x-894)
+                            ((lambda (lexical-e-895)
+                               (if (lexical-annotation?-158 lexical-e-895)
+                                   (annotation-expression lexical-e-895)
+                                   lexical-e-895))
+                             (if (lexical-syntax-object?-90 lexical-x-894)
+                                 (lexical-syntax-object-expression-91
+                                  lexical-x-894)
+                                 lexical-x-894)))
+                          lexical-i-892)
+                         ((lambda (lexical-x-896)
+                            ((lambda (lexical-e-897)
+                               (if (lexical-annotation?-158 lexical-e-897)
+                                   (annotation-expression lexical-e-897)
+                                   lexical-e-897))
+                             (if (lexical-syntax-object?-90 lexical-x-896)
+                                 (lexical-syntax-object-expression-91
+                                  lexical-x-896)
+                                 lexical-x-896)))
+                          lexical-j-893))
+                    (eq? (lexical-id-var-name-461 lexical-i-892 '(()))
+                         (lexical-id-var-name-461 lexical-j-893 '(())))
+                    '#f)))
+             (lexical-literal-id=?-463
+              (lambda (lexical-id-898 lexical-literal-899)
+                (if (eq? ((lambda (lexical-x-900)
+                            ((lambda (lexical-e-901)
+                               (if (lexical-annotation?-158 lexical-e-901)
+                                   (annotation-expression lexical-e-901)
+                                   lexical-e-901))
+                             (if (lexical-syntax-object?-90 lexical-x-900)
+                                 (lexical-syntax-object-expression-91
+                                  lexical-x-900)
+                                 lexical-x-900)))
+                          lexical-id-898)
+                         ((lambda (lexical-x-902)
+                            ((lambda (lexical-e-903)
+                               (if (lexical-annotation?-158 lexical-e-903)
+                                   (annotation-expression lexical-e-903)
+                                   lexical-e-903))
+                             (if (lexical-syntax-object?-90 lexical-x-902)
+                                 (lexical-syntax-object-expression-91
+                                  lexical-x-902)
+                                 lexical-x-902)))
+                          lexical-literal-899))
+                    ((lambda (lexical-n-id-904 lexical-n-literal-905)
+                       ((lambda (lexical-t-906)
+                          (if lexical-t-906
+                              lexical-t-906
+                              (if ((lambda (lexical-t-907)
+                                     (if lexical-t-907
+                                         lexical-t-907
+                                         (symbol? lexical-n-id-904)))
+                                   (not lexical-n-id-904))
+                                  ((lambda (lexical-t-908)
+                                     (if lexical-t-908
+                                         lexical-t-908
+                                         (symbol? lexical-n-literal-905)))
+                                   (not lexical-n-literal-905))
+                                  '#f)))
+                        (eq? lexical-n-id-904 lexical-n-literal-905)))
+                     (lexical-id-var-name-461 lexical-id-898 '(()))
+                     (lexical-id-var-name-461 lexical-literal-899 '(())))
+                    '#f)))
+             (lexical-help-bound-id=?-464
+              (lambda (lexical-i.sym-909
+                       lexical-i.marks-910
+                       lexical-j.sym-911
+                       lexical-j.marks-912)
+                (if (eq? lexical-i.sym-909 lexical-j.sym-911)
+                    (lexical-same-marks?-452
+                     lexical-i.marks-910
+                     lexical-j.marks-912)
+                    '#f)))
+             (lexical-bound-id=?-465
+              (lambda (lexical-i-913 lexical-j-914)
+                (lexical-help-bound-id=?-464
+                 ((lambda (lexical-x-915)
+                    ((lambda (lexical-e-916)
+                       (if (lexical-annotation?-158 lexical-e-916)
+                           (annotation-expression lexical-e-916)
+                           lexical-e-916))
+                     (if (lexical-syntax-object?-90 lexical-x-915)
+                         (lexical-syntax-object-expression-91 lexical-x-915)
+                         lexical-x-915)))
+                  lexical-i-913)
+                 (lexical-id-marks-339 lexical-i-913)
+                 ((lambda (lexical-x-917)
+                    ((lambda (lexical-e-918)
+                       (if (lexical-annotation?-158 lexical-e-918)
+                           (annotation-expression lexical-e-918)
+                           lexical-e-918))
+                     (if (lexical-syntax-object?-90 lexical-x-917)
+                         (lexical-syntax-object-expression-91 lexical-x-917)
+                         lexical-x-917)))
+                  lexical-j-914)
+                 (lexical-id-marks-339 lexical-j-914))))
+             (lexical-valid-bound-ids?-466
+              (lambda (lexical-ids-919)
+                (if ((letrec ((lexical-all-ids?-920
+                               (lambda (lexical-ids-921)
+                                 ((lambda (lexical-t-922)
+                                    (if lexical-t-922
+                                        lexical-t-922
+                                        (if (lexical-id?-333
+                                             (car lexical-ids-921))
+                                            (lexical-all-ids?-920
+                                             (cdr lexical-ids-921))
+                                            '#f)))
+                                  (null? lexical-ids-921)))))
+                       lexical-all-ids?-920)
+                     lexical-ids-919)
+                    (lexical-distinct-bound-ids?-467 lexical-ids-919)
+                    '#f)))
+             (lexical-distinct-bound-ids?-467
+              (lambda (lexical-ids-923)
+                ((letrec ((lexical-distinct?-924
+                           (lambda (lexical-ids-925)
+                             ((lambda (lexical-t-926)
+                                (if lexical-t-926
+                                    lexical-t-926
+                                    (if (not (lexical-bound-id-member?-469
+                                              (car lexical-ids-925)
+                                              (cdr lexical-ids-925)))
+                                        (lexical-distinct?-924
+                                         (cdr lexical-ids-925))
+                                        '#f)))
+                              (null? lexical-ids-925)))))
+                   lexical-distinct?-924)
+                 lexical-ids-923)))
+             (lexical-invalid-ids-error-468
+              (lambda (lexical-ids-927 lexical-exp-928 lexical-class-929)
+                ((letrec ((lexical-find-930
+                           (lambda (lexical-ids-931 lexical-gooduns-932)
+                             (if (null? lexical-ids-931)
+                                 (syntax-error lexical-exp-928)
+                                 (if (lexical-id?-333 (car lexical-ids-931))
+                                     (if (lexical-bound-id-member?-469
+                                          (car lexical-ids-931)
+                                          lexical-gooduns-932)
+                                         (syntax-error
+                                          (car lexical-ids-931)
+                                          '"duplicate "
+                                          lexical-class-929)
+                                         (lexical-find-930
+                                          (cdr lexical-ids-931)
+                                          (cons (car lexical-ids-931)
+                                                lexical-gooduns-932)))
+                                     (syntax-error
+                                      (car lexical-ids-931)
+                                      '"invalid "
+                                      lexical-class-929))))))
+                   lexical-find-930)
+                 lexical-ids-927
+                 '())))
+             (lexical-bound-id-member?-469
+              (lambda (lexical-x-933 lexical-list-934)
+                (if (not (null? lexical-list-934))
+                    ((lambda (lexical-t-935)
+                       (if lexical-t-935
+                           lexical-t-935
+                           (lexical-bound-id-member?-469
+                            lexical-x-933
+                            (cdr lexical-list-934))))
+                     (lexical-bound-id=?-465
+                      lexical-x-933
+                      (car lexical-list-934)))
+                    '#f)))
+             (lexical-wrap-470
+              (lambda (lexical-x-936 lexical-w-937)
+                (if (if (null? (lexical-wrap-marks-343 lexical-w-937))
+                        (null? (lexical-wrap-subst-344 lexical-w-937))
+                        '#f)
+                    lexical-x-936
+                    (if (lexical-syntax-object?-90 lexical-x-936)
+                        (lexical-make-syntax-object-89
+                         (lexical-syntax-object-expression-91 lexical-x-936)
+                         (lexical-join-wraps-449
+                          lexical-w-937
+                          (lexical-syntax-object-wrap-92 lexical-x-936)))
+                        (if (null? lexical-x-936)
+                            lexical-x-936
+                            (lexical-make-syntax-object-89
+                             lexical-x-936
+                             lexical-w-937))))))
+             (lexical-source-wrap-471
+              (lambda (lexical-x-938 lexical-w-939 lexical-ae-940)
+                (lexical-wrap-470
+                 (if (lexical-annotation?-158 lexical-ae-940)
+                     (begin
+                       (if (not (eq? (annotation-expression lexical-ae-940)
+                                     lexical-x-938))
+                           (error 'sc-expand
+                                  '"internal error in source-wrap: ae/x mismatch")
+                           (void))
+                       lexical-ae-940)
+                     lexical-x-938)
+                 lexical-w-939)))
+             (lexical-chi-when-list-472
+              (lambda (lexical-when-list-941 lexical-w-942)
+                (map (lambda (lexical-x-943)
+                       (if (lexical-literal-id=?-463
+                            lexical-x-943
+                            '#(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
+                                   call-or-value
+                                   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?
+                                   tmp-wrap
+                                   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-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
+                                   update-import-binding!
+                                   get-import-binding
+                                   read-only-binding?
+                                   put-global-definition-hook
+                                   get-global-definition-hook
+                                   put-cte-hook
+                                   error-hook
+                                   define-top-level-value-hook
+                                   local-eval-hook
+                                   top-level-eval-hook
+                                   annotation?
+                                   fx>=
+                                   fx<=
+                                   fx>
+                                   fx<
+                                   fx=
+                                   fx-
+                                   fx+
+                                   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)
+                                   (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)
+                                   (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"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"))
+                                #(top-ribcage *top* #t))))
+                           'compile
+                           (if (lexical-literal-id=?-463
+                                lexical-x-943
+                                '#(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
+                                       call-or-value
+                                       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?
+                                       tmp-wrap
+                                       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-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
+                                       update-import-binding!
+                                       get-import-binding
+                                       read-only-binding?
+                                       put-global-definition-hook
+                                       get-global-definition-hook
+                                       put-cte-hook
+                                       error-hook
+                                       define-top-level-value-hook
+                                       local-eval-hook
+                                       top-level-eval-hook
+                                       annotation?
+                                       fx>=
+                                       fx<=
+                                       fx>
+                                       fx<
+                                       fx=
+                                       fx-
+                                       fx+
+                                       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)
+                                       (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)
+                                       (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"
+                                       "i"
+                                       "i"
+                                       "i"
+                                       "i"
+                                       "i"
+                                       "i"
+                                       "i"
+                                       "i"
+                                       "i"))
+                                    #(top-ribcage *top* #t))))
+                               'load
+                               (if (lexical-literal-id=?-463
+                                    lexical-x-943
+                                    '#(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
+                                           call-or-value
+                                           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?
+                                           tmp-wrap
+                                           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-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
+                                           update-import-binding!
+                                           get-import-binding
+                                           read-only-binding?
+                                           put-global-definition-hook
+                                           get-global-definition-hook
+                                           put-cte-hook
+                                           error-hook
+                                           define-top-level-value-hook
+                                           local-eval-hook
+                                           top-level-eval-hook
+                                           annotation?
+                                           fx>=
+                                           fx<=
+                                           fx>
+                                           fx<
+                                           fx=
+                                           fx-
+                                           fx+
+                                           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)
+                                           (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)
+                                           (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"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"))
+                                        #(top-ribcage *top* #t))))
+                                   'visit
+                                   (if (lexical-literal-id=?-463
+                                        lexical-x-943
+                                        '#(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
+                                               call-or-value
+                                               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?
+                                               tmp-wrap
+                                               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-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
+                                               update-import-binding!
+                                               get-import-binding
+                                               read-only-binding?
+                                               put-global-definition-hook
+                                               get-global-definition-hook
+                                               put-cte-hook
+                                               error-hook
+                                               define-top-level-value-hook
+                                               local-eval-hook
+                                               top-level-eval-hook
+                                               annotation?
+                                               fx>=
+                                               fx<=
+                                               fx>
+                                               fx<
+                                               fx=
+                                               fx-
+                                               fx+
+                                               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)
+                                               (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)
+                                               (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"
+                                               "i"
+                                               "i"
+                                               "i"
+                                               "i"
+                                               "i"
+                                               "i"
+                                               "i"
+                                               "i"
+                                               "i"))
+                                            #(top-ribcage *top* #t))))
+                                       'revisit
+                                       (if (lexical-literal-id=?-463
+                                            lexical-x-943
+                                            '#(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
+                                                   call-or-value
+                                                   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?
+                                                   tmp-wrap
+                                                   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-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
+                                                   update-import-binding!
+                                                   get-import-binding
+                                                   read-only-binding?
+                                                   put-global-definition-hook
+                                                   get-global-definition-hook
+                                                   put-cte-hook
+                                                   error-hook
+                                                   define-top-level-value-hook
+                                                   local-eval-hook
+                                                   top-level-eval-hook
+                                                   annotation?
+                                                   fx>=
+                                                   fx<=
+                                                   fx>
+                                                   fx<
+                                                   fx=
+                                                   fx-
+                                                   fx+
+                                                   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)
+                                                   (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)
+                                                   (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"
+                                                   "i"
+                                                   "i"
+                                                   "i"
+                                                   "i"
+                                                   "i"
+                                                   "i"
+                                                   "i"
+                                                   "i"
+                                                   "i"))
+                                                #(top-ribcage *top* #t))))
+                                           'eval
+                                           (syntax-error
+                                            (lexical-wrap-470
+                                             lexical-x-943
+                                             lexical-w-942)
+                                            '"invalid eval-when situation")))))))
+                     lexical-when-list-941)))
+             (lexical-syntax-type-473
+              (lambda (lexical-e-944
+                       lexical-r-945
+                       lexical-w-946
+                       lexical-ae-947
+                       lexical-rib-948)
+                (if (symbol? lexical-e-944)
+                    ((lambda (lexical-n-949)
+                       ((lambda (lexical-b-950)
+                          ((lambda (lexical-type-951)
+                             ((lambda ()
+                                ((lambda (lexical-t-952)
+                                   (if (memv lexical-t-952 '(macro macro!))
+                                       (lexical-syntax-type-473
+                                        (lexical-chi-macro-529
+                                         (lexical-binding-value-309
+                                          lexical-b-950)
+                                         lexical-e-944
+                                         lexical-r-945
+                                         lexical-w-946
+                                         lexical-ae-947
+                                         lexical-rib-948)
+                                        lexical-r-945
+                                        '(())
+                                        '#f
+                                        lexical-rib-948)
+                                       (values
+                                        lexical-type-951
+                                        (lexical-binding-value-309
+                                         lexical-b-950)
+                                        lexical-e-944
+                                        lexical-w-946
+                                        lexical-ae-947)))
+                                 lexical-type-951))))
+                           (lexical-binding-type-308 lexical-b-950)))
+                        (lexical-lookup-328 lexical-n-949 lexical-r-945)))
+                     (lexical-id-var-name-461 lexical-e-944 lexical-w-946))
+                    (if (pair? lexical-e-944)
+                        ((lambda (lexical-first-953)
+                           (if (lexical-id?-333 lexical-first-953)
+                               ((lambda (lexical-n-954)
+                                  ((lambda (lexical-b-955)
+                                     ((lambda (lexical-type-956)
+                                        ((lambda ()
+                                           ((lambda (lexical-t-957)
+                                              (if (memv lexical-t-957
+                                                        '(lexical))
+                                                  (values
+                                                   'lexical-call
+                                                   (lexical-binding-value-309
+                                                    lexical-b-955)
+                                                   lexical-e-944
+                                                   lexical-w-946
+                                                   lexical-ae-947)
+                                                  (if (memv lexical-t-957
+                                                            '(macro macro!))
+                                                      (lexical-syntax-type-473
+                                                       (lexical-chi-macro-529
+                                                        (lexical-binding-value-309
+                                                         lexical-b-955)
+                                                        lexical-e-944
+                                                        lexical-r-945
+                                                        lexical-w-946
+                                                        lexical-ae-947
+                                                        lexical-rib-948)
+                                                       lexical-r-945
+                                                       '(())
+                                                       '#f
+                                                       lexical-rib-948)
+                                                      (if (memv lexical-t-957
+                                                                '(core))
+                                                          (values
+                                                           lexical-type-956
+                                                           (lexical-binding-value-309
+                                                            lexical-b-955)
+                                                           lexical-e-944
+                                                           lexical-w-946
+                                                           lexical-ae-947)
+                                                          (if (memv lexical-t-957
+                                                                    '(begin))
+                                                              (values
+                                                               'begin-form
+                                                               '#f
+                                                               lexical-e-944
+                                                               lexical-w-946
+                                                               lexical-ae-947)
+                                                              (if (memv lexical-t-957
+                                                                        '(alias))
+                                                                  (values
+                                                                   'alias-form
+                                                                   '#f
+                                                                   lexical-e-944
+                                                                   lexical-w-946
+                                                                   lexical-ae-947)
+                                                                  (if (memv lexical-t-957
+                                                                            '(define))
+                                                                      (values
+                                                                       'define-form
+                                                                       '#f
+                                                                       lexical-e-944
+                                                                       lexical-w-946
+                                                                       lexical-ae-947)
+                                                                      (if (memv lexical-t-957
+                                                                                '(define-syntax))
+                                                                          (values
+                                                                           'define-syntax-form
+                                                                           '#f
+                                                                           lexical-e-944
+                                                                           lexical-w-946
+                                                                           lexical-ae-947)
+                                                                          (if (memv lexical-t-957
+                                                                                    '(set!))
+                                                                              (lexical-chi-set!-528
+                                                                               lexical-e-944
+                                                                               lexical-r-945
+                                                                               lexical-w-946
+                                                                               lexical-ae-947
+                                                                               lexical-rib-948)
+                                                                              (if (memv lexical-t-957
+                                                                                        '($module-key))
+                                                                                  (values
+                                                                                   '$module-form
+                                                                                   '#f
+                                                                                   lexical-e-944
+                                                                                   lexical-w-946
+                                                                                   lexical-ae-947)
+                                                                                  (if (memv lexical-t-957
+                                                                                            '($import))
+                                                                                      (values
+                                                                                       '$import-form
+                                                                                       '#f
+                                                                                       lexical-e-944
+                                                                                       lexical-w-946
+                                                                                       lexical-ae-947)
+                                                                                      (if (memv lexical-t-957
+                                                                                                '(eval-when))
+                                                                                          (values
+                                                                                           'eval-when-form
+                                                                                           '#f
+                                                                                           lexical-e-944
+                                                                                           lexical-w-946
+                                                                                           lexical-ae-947)
+                                                                                          (if (memv lexical-t-957
+                                                                                                    '(meta))
+                                                                                              (values
+                                                                                               'meta-form
+                                                                                               '#f
+                                                                                               lexical-e-944
+                                                                                               lexical-w-946
+                                                                                               lexical-ae-947)
+                                                                                              (if (memv lexical-t-957
+                                                                                                        '(local-syntax))
+                                                                                                  (values
+                                                                                                   'local-syntax-form
+                                                                                                   (lexical-binding-value-309
+                                                                                                    lexical-b-955)
+                                                                                                   lexical-e-944
+                                                                                                   lexical-w-946
+                                                                                                   lexical-ae-947)
+                                                                                                  (values
+                                                                                                   'call
+                                                                                                   '#f
+                                                                                                   lexical-e-944
+                                                                                                   lexical-w-946
+                                                                                                   lexical-ae-947)))))))))))))))
+                                            lexical-type-956))))
+                                      (lexical-binding-type-308 lexical-b-955)))
+                                   (lexical-lookup-328
+                                    lexical-n-954
+                                    lexical-r-945)))
+                                (lexical-id-var-name-461
+                                 lexical-first-953
+                                 lexical-w-946))
+                               (values
+                                'call
+                                '#f
+                                lexical-e-944
+                                lexical-w-946
+                                lexical-ae-947)))
+                         (car lexical-e-944))
+                        (if (lexical-syntax-object?-90 lexical-e-944)
+                            (lexical-syntax-type-473
+                             (lexical-syntax-object-expression-91
+                              lexical-e-944)
+                             lexical-r-945
+                             (lexical-join-wraps-449
+                              lexical-w-946
+                              (lexical-syntax-object-wrap-92 lexical-e-944))
+                             '#f
+                             lexical-rib-948)
+                            (if (lexical-annotation?-158 lexical-e-944)
+                                (lexical-syntax-type-473
+                                 (annotation-expression lexical-e-944)
+                                 lexical-r-945
+                                 lexical-w-946
+                                 lexical-e-944
+                                 lexical-rib-948)
+                                (if ((lambda (lexical-x-958)
+                                       ((lambda (lexical-t-959)
+                                          (if lexical-t-959
+                                              lexical-t-959
+                                              ((lambda (lexical-t-960)
+                                                 (if lexical-t-960
+                                                     lexical-t-960
+                                                     ((lambda (lexical-t-961)
+                                                        (if lexical-t-961
+                                                            lexical-t-961
+                                                            ((lambda (lexical-t-962)
+                                                               (if lexical-t-962
+                                                                   lexical-t-962
+                                                                   (null? lexical-x-958)))
+                                                             (char? lexical-x-958))))
+                                                      (string? lexical-x-958))))
+                                               (number? lexical-x-958))))
+                                        (boolean? lexical-x-958)))
+                                     lexical-e-944)
+                                    (values
+                                     'constant
+                                     '#f
+                                     lexical-e-944
+                                     lexical-w-946
+                                     lexical-ae-947)
+                                    (values
+                                     'other
+                                     '#f
+                                     lexical-e-944
+                                     lexical-w-946
+                                     lexical-ae-947))))))))
+             (lexical-chi-top*-474
+              (lambda (lexical-e-963
+                       lexical-r-964
+                       lexical-w-965
+                       lexical-ctem-966
+                       lexical-rtem-967
+                       lexical-meta?-968
+                       lexical-top-ribcage-969)
+                ((lambda (lexical-meta-residuals-970)
+                   (letrec* ((lexical-meta-residualize!-971
+                              (lambda (lexical-x-972)
+                                (set! lexical-meta-residuals-970
+                                      (cons lexical-x-972
+                                            lexical-meta-residuals-970)))))
+                     ((lambda (lexical-e-973)
+                        (lexical-build-sequence-261
+                         '#f
+                         (reverse
+                          (cons lexical-e-973 lexical-meta-residuals-970))))
+                      (lexical-chi-top-476
+                       lexical-e-963
+                       lexical-r-964
+                       lexical-w-965
+                       lexical-ctem-966
+                       lexical-rtem-967
+                       lexical-meta?-968
+                       lexical-top-ribcage-969
+                       lexical-meta-residualize!-971
+                       '#f))))
+                 '())))
+             (lexical-chi-top-sequence-475
+              (lambda (lexical-body-974
+                       lexical-r-975
+                       lexical-w-976
+                       lexical-ae-977
+                       lexical-ctem-978
+                       lexical-rtem-979
+                       lexical-meta?-980
+                       lexical-ribcage-981
+                       lexical-meta-residualize!-982)
+                (lexical-build-sequence-261
+                 lexical-ae-977
+                 ((letrec ((lexical-dobody-983
+                            (lambda (lexical-body-984)
+                              (if (null? lexical-body-984)
+                                  '()
+                                  ((lambda (lexical-first-985)
+                                     (cons lexical-first-985
+                                           (lexical-dobody-983
+                                            (cdr lexical-body-984))))
+                                   (lexical-chi-top-476
+                                    (car lexical-body-984)
+                                    lexical-r-975
+                                    lexical-w-976
+                                    lexical-ctem-978
+                                    lexical-rtem-979
+                                    lexical-meta?-980
+                                    lexical-ribcage-981
+                                    lexical-meta-residualize!-982
+                                    '#f))))))
+                    lexical-dobody-983)
+                  lexical-body-974))))
+             (lexical-chi-top-476
+              (lambda (lexical-e-986
+                       lexical-r-987
+                       lexical-w-988
+                       lexical-ctem-989
+                       lexical-rtem-990
+                       lexical-meta?-991
+                       lexical-top-ribcage-992
+                       lexical-meta-residualize!-993
+                       lexical-meta-seen?-994)
+                (call-with-values
+                 (lambda ()
+                   (lexical-syntax-type-473
+                    lexical-e-986
+                    lexical-r-987
+                    lexical-w-988
+                    '#f
+                    lexical-top-ribcage-992))
+                 (lambda (lexical-type-995
+                          lexical-value-996
+                          lexical-e-997
+                          lexical-w-998
+                          lexical-ae-999)
+                   ((lambda (lexical-t-1000)
+                      (if (memv lexical-t-1000 '(begin-form))
+                          ((lambda (lexical-forms-1001)
+                             (if (null? lexical-forms-1001)
+                                 (lexical-chi-void-546)
+                                 (lexical-chi-top-sequence-475
+                                  lexical-forms-1001
+                                  lexical-r-987
+                                  lexical-w-998
+                                  lexical-ae-999
+                                  lexical-ctem-989
+                                  lexical-rtem-990
+                                  lexical-meta?-991
+                                  lexical-top-ribcage-992
+                                  lexical-meta-residualize!-993)))
+                           (lexical-parse-begin-543
+                            lexical-e-997
+                            lexical-w-998
+                            lexical-ae-999
+                            '#t))
+                          (if (memv lexical-t-1000 '(local-syntax-form))
+                              (call-with-values
+                               (lambda ()
+                                 (lexical-chi-local-syntax-545
+                                  lexical-value-996
+                                  lexical-e-997
+                                  lexical-r-987
+                                  lexical-r-987
+                                  lexical-w-998
+                                  lexical-ae-999))
+                               (lambda (lexical-forms-1002
+                                        lexical-r-1003
+                                        lexical-mr-1004
+                                        lexical-w-1005
+                                        lexical-ae-1006)
+                                 (lexical-chi-top-sequence-475
+                                  lexical-forms-1002
+                                  lexical-r-1003
+                                  lexical-w-1005
+                                  lexical-ae-1006
+                                  lexical-ctem-989
+                                  lexical-rtem-990
+                                  lexical-meta?-991
+                                  lexical-top-ribcage-992
+                                  lexical-meta-residualize!-993)))
+                              (if (memv lexical-t-1000 '(eval-when-form))
+                                  (call-with-values
+                                   (lambda ()
+                                     (lexical-parse-eval-when-541
+                                      lexical-e-997
+                                      lexical-w-998
+                                      lexical-ae-999))
+                                   (lambda (lexical-when-list-1007
+                                            lexical-forms-1008)
+                                     ((lambda (lexical-ctem-1009
+                                               lexical-rtem-1010)
+                                        (if (if (null? lexical-ctem-1009)
+                                                (null? lexical-rtem-1010)
+                                                '#f)
+                                            (lexical-chi-void-546)
+                                            (lexical-chi-top-sequence-475
+                                             lexical-forms-1008
+                                             lexical-r-987
+                                             lexical-w-998
+                                             lexical-ae-999
+                                             lexical-ctem-1009
+                                             lexical-rtem-1010
+                                             lexical-meta?-991
+                                             lexical-top-ribcage-992
+                                             lexical-meta-residualize!-993)))
+                                      (lexical-update-mode-set-517
+                                       lexical-when-list-1007
+                                       lexical-ctem-989)
+                                      (lexical-update-mode-set-517
+                                       lexical-when-list-1007
+                                       lexical-rtem-990))))
+                                  (if (memv lexical-t-1000 '(meta-form))
+                                      (lexical-chi-top-476
+                                       (lexical-parse-meta-540
+                                        lexical-e-997
+                                        lexical-w-998
+                                        lexical-ae-999)
+                                       lexical-r-987
+                                       lexical-w-998
+                                       lexical-ctem-989
+                                       lexical-rtem-990
+                                       '#t
+                                       lexical-top-ribcage-992
+                                       lexical-meta-residualize!-993
+                                       '#t)
+                                      (if (memv lexical-t-1000
+                                                '(define-syntax-form))
+                                          (call-with-values
+                                           (lambda ()
+                                             (lexical-parse-define-syntax-539
+                                              lexical-e-997
+                                              lexical-w-998
+                                              lexical-ae-999))
+                                           (lambda (lexical-id-1011
+                                                    lexical-rhs-1012
+                                                    lexical-w-1013)
+                                             ((lambda (lexical-id-1014)
+                                                (begin
+                                                  (if (lexical-displaced-lexical?-325
+                                                       lexical-id-1014
+                                                       lexical-r-987)
+                                                      (lexical-displaced-lexical-error-326
+                                                       lexical-id-1014)
+                                                      (void))
+                                                  (if (not (lexical-top-ribcage-mutable?-403
+                                                            lexical-top-ribcage-992))
+                                                      (syntax-error
+                                                       (lexical-source-wrap-471
+                                                        lexical-e-997
+                                                        lexical-w-1013
+                                                        lexical-ae-999)
+                                                       '"invalid definition in read-only environment")
+                                                      (void))
+                                                  ((lambda (lexical-sym-1015)
+                                                     (call-with-values
+                                                      (lambda ()
+                                                        (lexical-top-id-bound-var-name-456
+                                                         lexical-sym-1015
+                                                         (lexical-wrap-marks-343
+                                                          (lexical-syntax-object-wrap-92
+                                                           lexical-id-1014))
+                                                         lexical-top-ribcage-992))
+                                                      (lambda (lexical-valsym-1016
+                                                               lexical-bound-id-1017)
+                                                        (begin
+                                                          (if (not (eq? (lexical-id-var-name-461
+                                                                         lexical-id-1014
+                                                                         '(()))
+                                                                        lexical-valsym-1016))
+                                                              (syntax-error
+                                                               (lexical-source-wrap-471
+                                                                lexical-e-997
+                                                                lexical-w-1013
+                                                                lexical-ae-999)
+                                                               '"definition not permitted")
+                                                              (void))
+                                                          (if (lexical-read-only-binding?-166
+                                                               lexical-valsym-1016)
+                                                              (syntax-error
+                                                               (lexical-source-wrap-471
+                                                                lexical-e-997
+                                                                lexical-w-1013
+                                                                lexical-ae-999)
+                                                               '"invalid definition of read-only identifier")
+                                                              (void))
+                                                          (lexical-ct-eval/residualize2-520
+                                                           lexical-ctem-989
+                                                           (lambda ()
+                                                             (list '$sc-put-cte
+                                                                   (list 'quote
+                                                                         lexical-bound-id-1017)
+                                                                   (lexical-chi-525
+                                                                    lexical-rhs-1012
+                                                                    lexical-r-987
+                                                                    lexical-r-987
+                                                                    lexical-w-1013
+                                                                    '#t)
+                                                                   (list 'quote
+                                                                         (lexical-top-ribcage-key-402
+                                                                          lexical-top-ribcage-992)))))))))
+                                                   ((lambda (lexical-x-1018)
+                                                      ((lambda (lexical-e-1019)
+                                                         (if (lexical-annotation?-158
+                                                              lexical-e-1019)
+                                                             (annotation-expression
+                                                              lexical-e-1019)
+                                                             lexical-e-1019))
+                                                       (if (lexical-syntax-object?-90
+                                                            lexical-x-1018)
+                                                           (lexical-syntax-object-expression-91
+                                                            lexical-x-1018)
+                                                           lexical-x-1018)))
+                                                    lexical-id-1014))))
+                                              (lexical-wrap-470
+                                               lexical-id-1011
+                                               lexical-w-1013))))
+                                          (if (memv lexical-t-1000
+                                                    '(define-form))
+                                              (call-with-values
+                                               (lambda ()
+                                                 (lexical-parse-define-538
+                                                  lexical-e-997
+                                                  lexical-w-998
+                                                  lexical-ae-999))
+                                               (lambda (lexical-id-1020
+                                                        lexical-rhs-1021
+                                                        lexical-w-1022)
+                                                 ((lambda (lexical-id-1023)
+                                                    (begin
+                                                      (if (lexical-displaced-lexical?-325
+                                                           lexical-id-1023
+                                                           lexical-r-987)
+                                                          (lexical-displaced-lexical-error-326
+                                                           lexical-id-1023)
+                                                          (void))
+                                                      (if (not (lexical-top-ribcage-mutable?-403
+                                                                lexical-top-ribcage-992))
+                                                          (syntax-error
+                                                           (lexical-source-wrap-471
+                                                            lexical-e-997
+                                                            lexical-w-1022
+                                                            lexical-ae-999)
+                                                           '"invalid definition in read-only environment")
+                                                          (void))
+                                                      ((lambda (lexical-sym-1024)
+                                                         (call-with-values
+                                                          (lambda ()
+                                                            (lexical-top-id-bound-var-name-456
+                                                             lexical-sym-1024
+                                                             (lexical-wrap-marks-343
+                                                              (lexical-syntax-object-wrap-92
+                                                               lexical-id-1023))
+                                                             lexical-top-ribcage-992))
+                                                          (lambda (lexical-valsym-1025
+                                                                   lexical-bound-id-1026)
+                                                            (begin
+                                                              (if (not (eq? (lexical-id-var-name-461
+                                                                             lexical-id-1023
+                                                                             '(()))
+                                                                            lexical-valsym-1025))
+                                                                  (syntax-error
+                                                                   (lexical-source-wrap-471
+                                                                    lexical-e-997
+                                                                    lexical-w-1022
+                                                                    lexical-ae-999)
+                                                                   '"definition not permitted")
+                                                                  (void))
+                                                              (if (lexical-read-only-binding?-166
+                                                                   lexical-valsym-1025)
+                                                                  (syntax-error
+                                                                   (lexical-source-wrap-471
+                                                                    lexical-e-997
+                                                                    lexical-w-1022
+                                                                    lexical-ae-999)
+                                                                   '"invalid definition of read-only identifier")
+                                                                  (void))
+                                                              (if lexical-meta?-991
+                                                                  (lexical-ct-eval/residualize2-520
+                                                                   lexical-ctem-989
+                                                                   (lambda ()
+                                                                     (lexical-build-sequence-261
+                                                                      '#f
+                                                                      (list (list '$sc-put-cte
+                                                                                  (list 'quote
+                                                                                        lexical-bound-id-1026)
+                                                                                  (list 'quote
+                                                                                        (cons 'meta-variable
+                                                                                              lexical-valsym-1025))
+                                                                                  (list 'quote
+                                                                                        (lexical-top-ribcage-key-402
+                                                                                         lexical-top-ribcage-992)))
+                                                                            (list 'define
+                                                                                  lexical-valsym-1025
+                                                                                  (lexical-chi-525
+                                                                                   lexical-rhs-1021
+                                                                                   lexical-r-987
+                                                                                   lexical-r-987
+                                                                                   lexical-w-1022
+                                                                                   '#t))))))
+                                                                  ((lambda (lexical-x-1027)
+                                                                     (lexical-build-sequence-261
+                                                                      '#f
+                                                                      (list lexical-x-1027
+                                                                            (lexical-rt-eval/residualize-519
+                                                                             lexical-rtem-990
+                                                                             (lambda ()
+                                                                               (list 'define
+                                                                                     lexical-valsym-1025
+                                                                                     (lexical-chi-525
+                                                                                      lexical-rhs-1021
+                                                                                      lexical-r-987
+                                                                                      lexical-r-987
+                                                                                      lexical-w-1022
+                                                                                      '#f)))))))
+                                                                   (lexical-ct-eval/residualize2-520
+                                                                    lexical-ctem-989
+                                                                    (lambda ()
+                                                                      (list '$sc-put-cte
+                                                                            (list 'quote
+                                                                                  lexical-bound-id-1026)
+                                                                            (list 'quote
+                                                                                  (cons 'global
+                                                                                        lexical-valsym-1025))
+                                                                            (list 'quote
+                                                                                  (lexical-top-ribcage-key-402
+                                                                                   lexical-top-ribcage-992)))))))))))
+                                                       ((lambda (lexical-x-1028)
+                                                          ((lambda (lexical-e-1029)
+                                                             (if (lexical-annotation?-158
+                                                                  lexical-e-1029)
+                                                                 (annotation-expression
+                                                                  lexical-e-1029)
+                                                                 lexical-e-1029))
+                                                           (if (lexical-syntax-object?-90
+                                                                lexical-x-1028)
+                                                               (lexical-syntax-object-expression-91
+                                                                lexical-x-1028)
+                                                               lexical-x-1028)))
+                                                        lexical-id-1023))))
+                                                  (lexical-wrap-470
+                                                   lexical-id-1020
+                                                   lexical-w-1022))))
+                                              (if (memv lexical-t-1000
+                                                        '($module-form))
+                                                  ((lambda (lexical-ribcage-1030)
+                                                     (call-with-values
+                                                      (lambda ()
+                                                        (lexical-parse-module-536
+                                                         lexical-e-997
+                                                         lexical-w-998
+                                                         lexical-ae-999
+                                                         (lexical-make-wrap-342
+                                                          (lexical-wrap-marks-343
+                                                           lexical-w-998)
+                                                          (cons lexical-ribcage-1030
+                                                                (lexical-wrap-subst-344
+                                                                 lexical-w-998)))))
+                                                      (lambda (lexical-orig-1031
+                                                               lexical-id-1032
+                                                               lexical-exports-1033
+                                                               lexical-forms-1034)
+                                                        (begin
+                                                          (if (lexical-displaced-lexical?-325
+                                                               lexical-id-1032
+                                                               lexical-r-987)
+                                                              (lexical-displaced-lexical-error-326
+                                                               (lexical-wrap-470
+                                                                lexical-id-1032
+                                                                lexical-w-998))
+                                                              (void))
+                                                          (if (not (lexical-top-ribcage-mutable?-403
+                                                                    lexical-top-ribcage-992))
+                                                              (syntax-error
+                                                               lexical-orig-1031
+                                                               '"invalid definition in read-only environment")
+                                                              (void))
+                                                          (lexical-chi-top-module-509
+                                                           lexical-orig-1031
+                                                           lexical-r-987
+                                                           lexical-r-987
+                                                           lexical-top-ribcage-992
+                                                           lexical-ribcage-1030
+                                                           lexical-ctem-989
+                                                           lexical-rtem-990
+                                                           lexical-meta?-991
+                                                           lexical-id-1032
+                                                           lexical-exports-1033
+                                                           lexical-forms-1034
+                                                           lexical-meta-residualize!-993)))))
+                                                   (lexical-make-ribcage-392
+                                                    '()
+                                                    '()
+                                                    '()))
+                                                  (if (memv lexical-t-1000
+                                                            '($import-form))
+                                                      (call-with-values
+                                                       (lambda ()
+                                                         (lexical-parse-import-537
+                                                          lexical-e-997
+                                                          lexical-w-998
+                                                          lexical-ae-999))
+                                                       (lambda (lexical-orig-1035
+                                                                lexical-only?-1036
+                                                                lexical-mid-1037)
+                                                         (begin
+                                                           (if (not (lexical-top-ribcage-mutable?-403
+                                                                     lexical-top-ribcage-992))
+                                                               (syntax-error
+                                                                lexical-orig-1035
+                                                                '"invalid definition in read-only environment")
+                                                               (void))
+                                                           (lexical-ct-eval/residualize2-520
+                                                            lexical-ctem-989
+                                                            (lambda ()
+                                                              ((lambda (lexical-binding-1038)
+                                                                 ((lambda (lexical-t-1039)
+                                                                    (if (memv lexical-t-1039
+                                                                              '($module))
+                                                                        (lexical-do-top-import-516
+                                                                         lexical-only?-1036
+                                                                         lexical-top-ribcage-992
+                                                                         lexical-mid-1037
+                                                                         (lexical-interface-token-482
+                                                                          (lexical-binding-value-309
+                                                                           lexical-binding-1038)))
+                                                                        (if (memv lexical-t-1039
+                                                                                  '(displaced-lexical))
+                                                                            (lexical-displaced-lexical-error-326
+                                                                             lexical-mid-1037)
+                                                                            (syntax-error
+                                                                             lexical-mid-1037
+                                                                             '"unknown module"))))
+                                                                  (lexical-binding-type-308
+                                                                   lexical-binding-1038)))
+                                                               (lexical-lookup-328
+                                                                (lexical-id-var-name-461
+                                                                 lexical-mid-1037
+                                                                 '(()))
+                                                                '())))))))
+                                                      (if (memv lexical-t-1000
+                                                                '(alias-form))
+                                                          (call-with-values
+                                                           (lambda ()
+                                                             (lexical-parse-alias-542
+                                                              lexical-e-997
+                                                              lexical-w-998
+                                                              lexical-ae-999))
+                                                           (lambda (lexical-new-id-1040
+                                                                    lexical-old-id-1041)
+                                                             ((lambda (lexical-new-id-1042)
+                                                                (begin
+                                                                  (if (lexical-displaced-lexical?-325
+                                                                       lexical-new-id-1042
+                                                                       lexical-r-987)
+                                                                      (lexical-displaced-lexical-error-326
+                                                                       lexical-new-id-1042)
+                                                                      (void))
+                                                                  (if (not (lexical-top-ribcage-mutable?-403
+                                                                            lexical-top-ribcage-992))
+                                                                      (syntax-error
+                                                                       (lexical-source-wrap-471
+                                                                        lexical-e-997
+                                                                        lexical-w-998
+                                                                        lexical-ae-999)
+                                                                       '"invalid definition in read-only environment")
+                                                                      (void))
+                                                                  ((lambda (lexical-sym-1043)
+                                                                     (call-with-values
+                                                                      (lambda ()
+                                                                        (lexical-top-id-bound-var-name-456
+                                                                         lexical-sym-1043
+                                                                         (lexical-wrap-marks-343
+                                                                          (lexical-syntax-object-wrap-92
+                                                                           lexical-new-id-1042))
+                                                                         lexical-top-ribcage-992))
+                                                                      (lambda (lexical-valsym-1044
+                                                                               lexical-bound-id-1045)
+                                                                        (begin
+                                                                          (if (not (eq? (lexical-id-var-name-461
+                                                                                         lexical-new-id-1042
+                                                                                         '(()))
+                                                                                        lexical-valsym-1044))
+                                                                              (syntax-error
+                                                                               (lexical-source-wrap-471
+                                                                                lexical-e-997
+                                                                                lexical-w-998
+                                                                                lexical-ae-999)
+                                                                               '"definition not permitted")
+                                                                              (void))
+                                                                          (if (lexical-read-only-binding?-166
+                                                                               lexical-valsym-1044)
+                                                                              (syntax-error
+                                                                               (lexical-source-wrap-471
+                                                                                lexical-e-997
+                                                                                lexical-w-998
+                                                                                lexical-ae-999)
+                                                                               '"invalid definition of read-only identifier")
+                                                                              (void))
+                                                                          (lexical-ct-eval/residualize2-520
+                                                                           lexical-ctem-989
+                                                                           (lambda ()
+                                                                             (list '$sc-put-cte
+                                                                                   (list 'quote
+                                                                                         (lexical-make-resolved-id-445
+                                                                                          lexical-sym-1043
+                                                                                          (lexical-wrap-marks-343
+                                                                                           (lexical-syntax-object-wrap-92
+                                                                                            lexical-new-id-1042))
+                                                                                          (lexical-id-var-name-461
+                                                                                           lexical-old-id-1041
+                                                                                           lexical-w-998)))
+                                                                                   (list 'quote
+                                                                                         '(do-alias
+                                                                                           .
+                                                                                           #f))
+                                                                                   (list 'quote
+                                                                                         (lexical-top-ribcage-key-402
+                                                                                          lexical-top-ribcage-992)))))))))
+                                                                   ((lambda (lexical-x-1046)
+                                                                      ((lambda (lexical-e-1047)
+                                                                         (if (lexical-annotation?-158
+                                                                              lexical-e-1047)
+                                                                             (annotation-expression
+                                                                              lexical-e-1047)
+                                                                             lexical-e-1047))
+                                                                       (if (lexical-syntax-object?-90
+                                                                            lexical-x-1046)
+                                                                           (lexical-syntax-object-expression-91
+                                                                            lexical-x-1046)
+                                                                           lexical-x-1046)))
+                                                                    lexical-new-id-1042))))
+                                                              (lexical-wrap-470
+                                                               lexical-new-id-1040
+                                                               lexical-w-998))))
+                                                          (begin
+                                                            (if lexical-meta-seen?-994
+                                                                (syntax-error
+                                                                 (lexical-source-wrap-471
+                                                                  lexical-e-997
+                                                                  lexical-w-998
+                                                                  lexical-ae-999)
+                                                                 '"invalid meta definition")
+                                                                (void))
+                                                            (if lexical-meta?-991
+                                                                ((lambda (lexical-x-1048)
+                                                                   (begin
+                                                                     (lexical-top-level-eval-hook-159
+                                                                      lexical-x-1048)
+                                                                     (lexical-ct-eval/residualize3-521
+                                                                      lexical-ctem-989
+                                                                      void
+                                                                      (lambda ()
+                                                                        lexical-x-1048))))
+                                                                 (lexical-chi-expr-526
+                                                                  lexical-type-995
+                                                                  lexical-value-996
+                                                                  lexical-e-997
+                                                                  lexical-r-987
+                                                                  lexical-r-987
+                                                                  lexical-w-998
+                                                                  lexical-ae-999
+                                                                  '#t))
+                                                                (lexical-rt-eval/residualize-519
+                                                                 lexical-rtem-990
+                                                                 (lambda ()
+                                                                   (lexical-chi-expr-526
+                                                                    lexical-type-995
+                                                                    lexical-value-996
+                                                                    lexical-e-997
+                                                                    lexical-r-987
+                                                                    lexical-r-987
+                                                                    lexical-w-998
+                                                                    lexical-ae-999
+                                                                    '#f)))))))))))))))
+                    lexical-type-995)))))
+             (lexical-flatten-exports-477
+              (lambda (lexical-exports-1049)
+                ((letrec ((lexical-loop-1050
+                           (lambda (lexical-exports-1051 lexical-ls-1052)
+                             (if (null? lexical-exports-1051)
+                                 lexical-ls-1052
+                                 (lexical-loop-1050
+                                  (cdr lexical-exports-1051)
+                                  (if (pair? (car lexical-exports-1051))
+                                      (lexical-loop-1050
+                                       (car lexical-exports-1051)
+                                       lexical-ls-1052)
+                                      (cons (car lexical-exports-1051)
+                                            lexical-ls-1052)))))))
+                   lexical-loop-1050)
+                 lexical-exports-1049
+                 '())))
+             (lexical-make-interface-478
+              (lambda (lexical-marks-1053
+                       lexical-exports-1054
+                       lexical-token-1055)
+                (vector
+                 'interface
+                 lexical-marks-1053
+                 lexical-exports-1054
+                 lexical-token-1055)))
+             (lexical-interface?-479
+              (lambda (lexical-x-1056)
+                (if (vector? lexical-x-1056)
+                    (if (= (vector-length lexical-x-1056) '4)
+                        (eq? (vector-ref lexical-x-1056 '0) 'interface)
+                        '#f)
+                    '#f)))
+             (lexical-interface-marks-480
+              (lambda (lexical-x-1057) (vector-ref lexical-x-1057 '1)))
+             (lexical-interface-exports-481
+              (lambda (lexical-x-1058) (vector-ref lexical-x-1058 '2)))
+             (lexical-interface-token-482
+              (lambda (lexical-x-1059) (vector-ref lexical-x-1059 '3)))
+             (lexical-set-interface-marks!-483
+              (lambda (lexical-x-1060 lexical-update-1061)
+                (vector-set! lexical-x-1060 '1 lexical-update-1061)))
+             (lexical-set-interface-exports!-484
+              (lambda (lexical-x-1062 lexical-update-1063)
+                (vector-set! lexical-x-1062 '2 lexical-update-1063)))
+             (lexical-set-interface-token!-485
+              (lambda (lexical-x-1064 lexical-update-1065)
+                (vector-set! lexical-x-1064 '3 lexical-update-1065)))
+             (lexical-make-unresolved-interface-486
+              (lambda (lexical-mid-1066 lexical-exports-1067)
+                (lexical-make-interface-478
+                 (lexical-wrap-marks-343
+                  (lexical-syntax-object-wrap-92 lexical-mid-1066))
+                 (list->vector
+                  (map (lambda (lexical-x-1068)
+                         (if (pair? lexical-x-1068)
+                             (car lexical-x-1068)
+                             lexical-x-1068))
+                       lexical-exports-1067))
+                 '#f)))
+             (lexical-make-resolved-interface-487
+              (lambda (lexical-mid-1069
+                       lexical-exports-1070
+                       lexical-token-1071)
+                (lexical-make-interface-478
+                 (lexical-wrap-marks-343
+                  (lexical-syntax-object-wrap-92 lexical-mid-1069))
+                 (list->vector
+                  (map (lambda (lexical-x-1072)
+                         (lexical-id->resolved-id-446
+                          (if (pair? lexical-x-1072)
+                              (car lexical-x-1072)
+                              lexical-x-1072)))
+                       lexical-exports-1070))
+                 lexical-token-1071)))
+             (lexical-make-module-binding-488
+              (lambda (lexical-type-1073
+                       lexical-id-1074
+                       lexical-label-1075
+                       lexical-imps-1076
+                       lexical-val-1077
+                       lexical-exported-1078)
+                (vector
+                 'module-binding
+                 lexical-type-1073
+                 lexical-id-1074
+                 lexical-label-1075
+                 lexical-imps-1076
+                 lexical-val-1077
+                 lexical-exported-1078)))
+             (lexical-module-binding?-489
+              (lambda (lexical-x-1079)
+                (if (vector? lexical-x-1079)
+                    (if (= (vector-length lexical-x-1079) '7)
+                        (eq? (vector-ref lexical-x-1079 '0) 'module-binding)
+                        '#f)
+                    '#f)))
+             (lexical-module-binding-type-490
+              (lambda (lexical-x-1080) (vector-ref lexical-x-1080 '1)))
+             (lexical-module-binding-id-491
+              (lambda (lexical-x-1081) (vector-ref lexical-x-1081 '2)))
+             (lexical-module-binding-label-492
+              (lambda (lexical-x-1082) (vector-ref lexical-x-1082 '3)))
+             (lexical-module-binding-imps-493
+              (lambda (lexical-x-1083) (vector-ref lexical-x-1083 '4)))
+             (lexical-module-binding-val-494
+              (lambda (lexical-x-1084) (vector-ref lexical-x-1084 '5)))
+             (lexical-module-binding-exported-495
+              (lambda (lexical-x-1085) (vector-ref lexical-x-1085 '6)))
+             (lexical-set-module-binding-type!-496
+              (lambda (lexical-x-1086 lexical-update-1087)
+                (vector-set! lexical-x-1086 '1 lexical-update-1087)))
+             (lexical-set-module-binding-id!-497
+              (lambda (lexical-x-1088 lexical-update-1089)
+                (vector-set! lexical-x-1088 '2 lexical-update-1089)))
+             (lexical-set-module-binding-label!-498
+              (lambda (lexical-x-1090 lexical-update-1091)
+                (vector-set! lexical-x-1090 '3 lexical-update-1091)))
+             (lexical-set-module-binding-imps!-499
+              (lambda (lexical-x-1092 lexical-update-1093)
+                (vector-set! lexical-x-1092 '4 lexical-update-1093)))
+             (lexical-set-module-binding-val!-500
+              (lambda (lexical-x-1094 lexical-update-1095)
+                (vector-set! lexical-x-1094 '5 lexical-update-1095)))
+             (lexical-set-module-binding-exported!-501
+              (lambda (lexical-x-1096 lexical-update-1097)
+                (vector-set! lexical-x-1096 '6 lexical-update-1097)))
+             (lexical-create-module-binding-502
+              (lambda (lexical-type-1098
+                       lexical-id-1099
+                       lexical-label-1100
+                       lexical-imps-1101
+                       lexical-val-1102)
+                (lexical-make-module-binding-488
+                 lexical-type-1098
+                 lexical-id-1099
+                 lexical-label-1100
+                 lexical-imps-1101
+                 lexical-val-1102
+                 '#f)))
+             (lexical-make-frob-503
+              (lambda (lexical-e-1103 lexical-meta?-1104)
+                (vector 'frob lexical-e-1103 lexical-meta?-1104)))
+             (lexical-frob?-504
+              (lambda (lexical-x-1105)
+                (if (vector? lexical-x-1105)
+                    (if (= (vector-length lexical-x-1105) '3)
+                        (eq? (vector-ref lexical-x-1105 '0) 'frob)
+                        '#f)
+                    '#f)))
+             (lexical-frob-e-505
+              (lambda (lexical-x-1106) (vector-ref lexical-x-1106 '1)))
+             (lexical-frob-meta?-506
+              (lambda (lexical-x-1107) (vector-ref lexical-x-1107 '2)))
+             (lexical-set-frob-e!-507
+              (lambda (lexical-x-1108 lexical-update-1109)
+                (vector-set! lexical-x-1108 '1 lexical-update-1109)))
+             (lexical-set-frob-meta?!-508
+              (lambda (lexical-x-1110 lexical-update-1111)
+                (vector-set! lexical-x-1110 '2 lexical-update-1111)))
+             (lexical-chi-top-module-509
+              (lambda (lexical-orig-1112
+                       lexical-r-1113
+                       lexical-mr-1114
+                       lexical-top-ribcage-1115
+                       lexical-ribcage-1116
+                       lexical-ctem-1117
+                       lexical-rtem-1118
+                       lexical-meta?-1119
+                       lexical-id-1120
+                       lexical-exports-1121
+                       lexical-forms-1122
+                       lexical-meta-residualize!-1123)
+                ((lambda (lexical-fexports-1124)
+                   (call-with-values
+                    (lambda ()
+                      (lexical-chi-external-513
+                       lexical-ribcage-1116
+                       lexical-orig-1112
+                       (map (lambda (lexical-d-1125)
+                              (lexical-make-frob-503
+                               lexical-d-1125
+                               lexical-meta?-1119))
+                            lexical-forms-1122)
+                       lexical-r-1113
+                       lexical-mr-1114
+                       lexical-ctem-1117
+                       lexical-exports-1121
+                       lexical-fexports-1124
+                       lexical-meta-residualize!-1123))
+                    (lambda (lexical-r-1126
+                             lexical-mr-1127
+                             lexical-bindings-1128
+                             lexical-inits-1129)
+                      ((letrec ((lexical-process-exports-1130
+                                 (lambda (lexical-fexports-1131
+                                          lexical-ctdefs-1132)
+                                   (if (null? lexical-fexports-1131)
+                                       ((letrec ((lexical-process-locals-1133
+                                                  (lambda (lexical-bs-1134
+                                                           lexical-r-1135
+                                                           lexical-dts-1136
+                                                           lexical-dvs-1137
+                                                           lexical-des-1138)
+                                                    (if (null? lexical-bs-1134)
+                                                        ((lambda (lexical-des-1139
+                                                                  lexical-inits-1140)
+                                                           (lexical-build-sequence-261
+                                                            '#f
+                                                            (append
+                                                             (lexical-ctdefs-1132)
+                                                             (list (lexical-ct-eval/residualize2-520
+                                                                    lexical-ctem-1117
+                                                                    (lambda ()
+                                                                      ((lambda (lexical-sym-1141)
+                                                                         ((lambda (lexical-token-1142)
+                                                                            ((lambda (lexical-b-1143)
+                                                                               ((lambda ()
+                                                                                  (call-with-values
+                                                                                   (lambda ()
+                                                                                     (lexical-top-id-bound-var-name-456
+                                                                                      lexical-sym-1141
+                                                                                      (lexical-wrap-marks-343
+                                                                                       (lexical-syntax-object-wrap-92
+                                                                                        lexical-id-1120))
+                                                                                      lexical-top-ribcage-1115))
+                                                                                   (lambda (lexical-valsym-1144
+                                                                                            lexical-bound-id-1145)
+                                                                                     (begin
+                                                                                       (if (not (eq? (lexical-id-var-name-461
+                                                                                                      lexical-id-1120
+                                                                                                      '(()))
+                                                                                                     lexical-valsym-1144))
+                                                                                           (syntax-error
+                                                                                            lexical-orig-1112
+                                                                                            '"definition not permitted")
+                                                                                           (void))
+                                                                                       (if (lexical-read-only-binding?-166
+                                                                                            lexical-valsym-1144)
+                                                                                           (syntax-error
+                                                                                            lexical-orig-1112
+                                                                                            '"invalid definition of read-only identifier")
+                                                                                           (void))
+                                                                                       (list '$sc-put-cte
+                                                                                             (list 'quote
+                                                                                                   lexical-bound-id-1145)
+                                                                                             lexical-b-1143
+                                                                                             (list 'quote
+                                                                                                   (lexical-top-ribcage-key-402
+                                                                                                    lexical-top-ribcage-1115)))))))))
+                                                                             (list 'quote
+                                                                                   (cons '$module
+                                                                                         (lexical-make-resolved-interface-487
+                                                                                          lexical-id-1120
+                                                                                          lexical-exports-1121
+                                                                                          lexical-token-1142)))))
+                                                                          (lexical-generate-id-169
+                                                                           lexical-sym-1141)))
+                                                                       ((lambda (lexical-x-1146)
+                                                                          ((lambda (lexical-e-1147)
+                                                                             (if (lexical-annotation?-158
+                                                                                  lexical-e-1147)
+                                                                                 (annotation-expression
+                                                                                  lexical-e-1147)
+                                                                                 lexical-e-1147))
+                                                                           (if (lexical-syntax-object?-90
+                                                                                lexical-x-1146)
+                                                                               (lexical-syntax-object-expression-91
+                                                                                lexical-x-1146)
+                                                                               lexical-x-1146)))
+                                                                        lexical-id-1120))))
+                                                                   (lexical-rt-eval/residualize-519
+                                                                    lexical-rtem-1118
+                                                                    (lambda ()
+                                                                      (lexical-build-top-module-265
+                                                                       '#f
+                                                                       lexical-dts-1136
+                                                                       lexical-dvs-1137
+                                                                       lexical-des-1139
+                                                                       (if (null? lexical-inits-1140)
+                                                                           (lexical-chi-void-546)
+                                                                           (lexical-build-sequence-261
+                                                                            '#f
+                                                                            (append
+                                                                             lexical-inits-1140
+                                                                             (list (lexical-chi-void-546))))))))))))
+                                                         (lexical-chi-frobs-522
+                                                          lexical-des-1138
+                                                          lexical-r-1135
+                                                          lexical-mr-1127
+                                                          '#f)
+                                                         (lexical-chi-frobs-522
+                                                          lexical-inits-1129
+                                                          lexical-r-1135
+                                                          lexical-mr-1127
+                                                          '#f))
+                                                        ((lambda (lexical-b-1148
+                                                                  lexical-bs-1149)
+                                                           ((lambda (lexical-t-1150)
+                                                              ((lambda (lexical-t-1151)
+                                                                 (if (memv lexical-t-1151
+                                                                           '(define-form))
+                                                                     ((lambda (lexical-label-1152)
+                                                                        (if (lexical-module-binding-exported-495
+                                                                             lexical-b-1148)
+                                                                            ((lambda (lexical-var-1153)
+                                                                               (lexical-process-locals-1133
+                                                                                lexical-bs-1149
+                                                                                lexical-r-1135
+                                                                                (cons 'global
+                                                                                      lexical-dts-1136)
+                                                                                (cons lexical-label-1152
+                                                                                      lexical-dvs-1137)
+                                                                                (cons (lexical-module-binding-val-494
+                                                                                       lexical-b-1148)
+                                                                                      lexical-des-1138)))
+                                                                             (lexical-module-binding-id-491
+                                                                              lexical-b-1148))
+                                                                            ((lambda (lexical-var-1154)
+                                                                               (lexical-process-locals-1133
+                                                                                lexical-bs-1149
+                                                                                (lexical-extend-env-322
+                                                                                 lexical-label-1152
+                                                                                 (cons 'lexical
+                                                                                       lexical-var-1154)
+                                                                                 lexical-r-1135)
+                                                                                (cons 'local
+                                                                                      lexical-dts-1136)
+                                                                                (cons lexical-var-1154
+                                                                                      lexical-dvs-1137)
+                                                                                (cons (lexical-module-binding-val-494
+                                                                                       lexical-b-1148)
+                                                                                      lexical-des-1138)))
+                                                                             (lexical-gen-var-551
+                                                                              (lexical-module-binding-id-491
+                                                                               lexical-b-1148)))))
+                                                                      (lexical-get-indirect-label-387
+                                                                       (lexical-module-binding-label-492
+                                                                        lexical-b-1148)))
+                                                                     (if (memv lexical-t-1151
+                                                                               '(ctdefine-form
+                                                                                 define-syntax-form
+                                                                                 $module-form
+                                                                                 alias-form))
+                                                                         (lexical-process-locals-1133
+                                                                          lexical-bs-1149
+                                                                          lexical-r-1135
+                                                                          lexical-dts-1136
+                                                                          lexical-dvs-1137
+                                                                          lexical-des-1138)
+                                                                         (error 'sc-expand-internal
+                                                                                '"unexpected module binding type ~s"
+                                                                                lexical-t-1150))))
+                                                               (lexical-module-binding-type-490
+                                                                lexical-b-1148)))
+                                                            (lexical-module-binding-type-490
+                                                             lexical-b-1148)))
+                                                         (car lexical-bs-1134)
+                                                         (cdr lexical-bs-1134))))))
+                                          lexical-process-locals-1133)
+                                        lexical-bindings-1128
+                                        lexical-r-1126
+                                        '()
+                                        '()
+                                        '())
+                                       ((lambda (lexical-id-1155
+                                                 lexical-fexports-1156)
+                                          ((letrec ((lexical-loop-1157
+                                                     (lambda (lexical-bs-1158)
+                                                       (if (null? lexical-bs-1158)
+                                                           (lexical-process-exports-1130
+                                                            lexical-fexports-1156
+                                                            lexical-ctdefs-1132)
+                                                           ((lambda (lexical-b-1159
+                                                                     lexical-bs-1160)
+                                                              (if (lexical-free-id=?-462
+                                                                   (lexical-module-binding-id-491
+                                                                    lexical-b-1159)
+                                                                   lexical-id-1155)
+                                                                  (if (lexical-module-binding-exported-495
+                                                                       lexical-b-1159)
+                                                                      (lexical-process-exports-1130
+                                                                       lexical-fexports-1156
+                                                                       lexical-ctdefs-1132)
+                                                                      ((lambda (lexical-t-1161)
+                                                                         ((lambda (lexical-label-1162)
+                                                                            ((lambda (lexical-imps-1163)
+                                                                               ((lambda (lexical-fexports-1164)
+                                                                                  ((lambda ()
+                                                                                     (begin
+                                                                                       (lexical-set-module-binding-exported!-501
+                                                                                        lexical-b-1159
+                                                                                        '#t)
+                                                                                       ((lambda (lexical-t-1165)
+                                                                                          (if (memv lexical-t-1165
+                                                                                                    '(define-form))
+                                                                                              ((lambda (lexical-sym-1166)
+                                                                                                 (begin
+                                                                                                   (lexical-set-indirect-label!-388
+                                                                                                    lexical-label-1162
+                                                                                                    lexical-sym-1166)
+                                                                                                   (lexical-process-exports-1130
+                                                                                                    lexical-fexports-1164
+                                                                                                    lexical-ctdefs-1132)))
+                                                                                               (lexical-generate-id-169
+                                                                                                ((lambda (lexical-x-1167)
+                                                                                                   ((lambda (lexical-e-1168)
+                                                                                                      (if (lexical-annotation?-158
+                                                                                                           lexical-e-1168)
+                                                                                                          (annotation-expression
+                                                                                                           lexical-e-1168)
+                                                                                                          lexical-e-1168))
+                                                                                                    (if (lexical-syntax-object?-90
+                                                                                                         lexical-x-1167)
+                                                                                                        (lexical-syntax-object-expression-91
+                                                                                                         lexical-x-1167)
+                                                                                                        lexical-x-1167)))
+                                                                                                 lexical-id-1155)))
+                                                                                              (if (memv lexical-t-1165
+                                                                                                        '(ctdefine-form))
+                                                                                                  ((lambda (lexical-b-1169)
+                                                                                                     (lexical-process-exports-1130
+                                                                                                      lexical-fexports-1164
+                                                                                                      (lambda ()
+                                                                                                        ((lambda (lexical-sym-1170)
+                                                                                                           (begin
+                                                                                                             (lexical-set-indirect-label!-388
+                                                                                                              lexical-label-1162
+                                                                                                              lexical-sym-1170)
+                                                                                                             (cons (lexical-ct-eval/residualize3-521
+                                                                                                                    lexical-ctem-1117
+                                                                                                                    (lambda ()
+                                                                                                                      (lexical-put-cte-hook-163
+                                                                                                                       lexical-sym-1170
+                                                                                                                       lexical-b-1169))
+                                                                                                                    (lambda ()
+                                                                                                                      (list '$sc-put-cte
+                                                                                                                            (list 'quote
+                                                                                                                                  lexical-sym-1170)
+                                                                                                                            (list 'quote
+                                                                                                                                  lexical-b-1169)
+                                                                                                                            (list 'quote
+                                                                                                                                  '#f))))
+                                                                                                                   (lexical-ctdefs-1132))))
+                                                                                                         (lexical-binding-value-309
+                                                                                                          lexical-b-1169)))))
+                                                                                                   (lexical-module-binding-val-494
+                                                                                                    lexical-b-1159))
+                                                                                                  (if (memv lexical-t-1165
+                                                                                                            '(define-syntax-form))
+                                                                                                      ((lambda (lexical-sym-1171)
+                                                                                                         (lexical-process-exports-1130
+                                                                                                          lexical-fexports-1164
+                                                                                                          (lambda ()
+                                                                                                            ((lambda (lexical-local-label-1172)
+                                                                                                               (begin
+                                                                                                                 (lexical-set-indirect-label!-388
+                                                                                                                  lexical-label-1162
+                                                                                                                  lexical-sym-1171)
+                                                                                                                 (cons (lexical-ct-eval/residualize3-521
+                                                                                                                        lexical-ctem-1117
+                                                                                                                        (lambda ()
+                                                                                                                          (lexical-put-cte-hook-163
+                                                                                                                           lexical-sym-1171
+                                                                                                                           (car (lexical-module-binding-val-494
+                                                                                                                                 lexical-b-1159))))
+                                                                                                                        (lambda ()
+                                                                                                                          (list '$sc-put-cte
+                                                                                                                                (list 'quote
+                                                                                                                                      lexical-sym-1171)
+                                                                                                                                (cdr (lexical-module-binding-val-494
+                                                                                                                                      lexical-b-1159))
+                                                                                                                                (list 'quote
+                                                                                                                                      '#f))))
+                                                                                                                       (lexical-ctdefs-1132))))
+                                                                                                             (lexical-get-indirect-label-387
+                                                                                                              lexical-label-1162)))))
+                                                                                                       (lexical-generate-id-169
+                                                                                                        ((lambda (lexical-x-1173)
+                                                                                                           ((lambda (lexical-e-1174)
+                                                                                                              (if (lexical-annotation?-158
+                                                                                                                   lexical-e-1174)
+                                                                                                                  (annotation-expression
+                                                                                                                   lexical-e-1174)
+                                                                                                                  lexical-e-1174))
+                                                                                                            (if (lexical-syntax-object?-90
+                                                                                                                 lexical-x-1173)
+                                                                                                                (lexical-syntax-object-expression-91
+                                                                                                                 lexical-x-1173)
+                                                                                                                lexical-x-1173)))
+                                                                                                         lexical-id-1155)))
+                                                                                                      (if (memv lexical-t-1165
+                                                                                                                '($module-form))
+                                                                                                          ((lambda (lexical-sym-1175
+                                                                                                                    lexical-exports-1176)
+                                                                                                             (lexical-process-exports-1130
+                                                                                                              (append
+                                                                                                               (lexical-flatten-exports-477
+                                                                                                                lexical-exports-1176)
+                                                                                                               lexical-fexports-1164)
+                                                                                                              (lambda ()
+                                                                                                                (begin
+                                                                                                                  (lexical-set-indirect-label!-388
+                                                                                                                   lexical-label-1162
+                                                                                                                   lexical-sym-1175)
+                                                                                                                  ((lambda (lexical-rest-1177)
+                                                                                                                     ((lambda (lexical-x-1178)
+                                                                                                                        (cons (lexical-ct-eval/residualize3-521
+                                                                                                                               lexical-ctem-1117
+                                                                                                                               (lambda ()
+                                                                                                                                 (lexical-put-cte-hook-163
+                                                                                                                                  lexical-sym-1175
+                                                                                                                                  lexical-x-1178))
+                                                                                                                               (lambda ()
+                                                                                                                                 (list '$sc-put-cte
+                                                                                                                                       (list 'quote
+                                                                                                                                             lexical-sym-1175)
+                                                                                                                                       (list 'quote
+                                                                                                                                             lexical-x-1178)
+                                                                                                                                       (list 'quote
+                                                                                                                                             '#f))))
+                                                                                                                              lexical-rest-1177))
+                                                                                                                      (cons '$module
+                                                                                                                            (lexical-make-resolved-interface-487
+                                                                                                                             lexical-id-1155
+                                                                                                                             lexical-exports-1176
+                                                                                                                             lexical-sym-1175))))
+                                                                                                                   (lexical-ctdefs-1132))))))
+                                                                                                           (lexical-generate-id-169
+                                                                                                            ((lambda (lexical-x-1179)
+                                                                                                               ((lambda (lexical-e-1180)
+                                                                                                                  (if (lexical-annotation?-158
+                                                                                                                       lexical-e-1180)
+                                                                                                                      (annotation-expression
+                                                                                                                       lexical-e-1180)
+                                                                                                                      lexical-e-1180))
+                                                                                                                (if (lexical-syntax-object?-90
+                                                                                                                     lexical-x-1179)
+                                                                                                                    (lexical-syntax-object-expression-91
+                                                                                                                     lexical-x-1179)
+                                                                                                                    lexical-x-1179)))
+                                                                                                             lexical-id-1155))
+                                                                                                           (lexical-module-binding-val-494
+                                                                                                            lexical-b-1159))
+                                                                                                          (if (memv lexical-t-1165
+                                                                                                                    '(alias-form))
+                                                                                                              (lexical-process-exports-1130
+                                                                                                               lexical-fexports-1164
+                                                                                                               (lambda ()
+                                                                                                                 ((lambda (lexical-rest-1181)
+                                                                                                                    (begin
+                                                                                                                      (if (lexical-indirect-label?-383
+                                                                                                                           lexical-label-1162)
+                                                                                                                          (if (not (symbol?
+                                                                                                                                    (lexical-get-indirect-label-387
+                                                                                                                                     lexical-label-1162)))
+                                                                                                                              (syntax-error
+                                                                                                                               (lexical-module-binding-id-491
+                                                                                                                                lexical-b-1159)
+                                                                                                                               '"unexported target of alias")
+                                                                                                                              (void))
+                                                                                                                          (void))
+                                                                                                                      lexical-rest-1181))
+                                                                                                                  (lexical-ctdefs-1132))))
+                                                                                                              (error 'sc-expand-internal
+                                                                                                                     '"unexpected module binding type ~s"
+                                                                                                                     lexical-t-1161)))))))
+                                                                                        lexical-t-1161)))))
+                                                                                (append
+                                                                                 lexical-imps-1163
+                                                                                 lexical-fexports-1156)))
+                                                                             (lexical-module-binding-imps-493
+                                                                              lexical-b-1159)))
+                                                                          (lexical-module-binding-label-492
+                                                                           lexical-b-1159)))
+                                                                       (lexical-module-binding-type-490
+                                                                        lexical-b-1159)))
+                                                                  (lexical-loop-1157
+                                                                   lexical-bs-1160)))
+                                                            (car lexical-bs-1158)
+                                                            (cdr lexical-bs-1158))))))
+                                             lexical-loop-1157)
+                                           lexical-bindings-1128))
+                                        (car lexical-fexports-1131)
+                                        (cdr lexical-fexports-1131))))))
+                         lexical-process-exports-1130)
+                       lexical-fexports-1124
+                       (lambda () '())))))
+                 (lexical-flatten-exports-477 lexical-exports-1121))))
+             (lexical-id-set-diff-510
+              (lambda (lexical-exports-1182 lexical-defs-1183)
+                (if (null? lexical-exports-1182)
+                    '()
+                    (if (lexical-bound-id-member?-469
+                         (car lexical-exports-1182)
+                         lexical-defs-1183)
+                        (lexical-id-set-diff-510
+                         (cdr lexical-exports-1182)
+                         lexical-defs-1183)
+                        (cons (car lexical-exports-1182)
+                              (lexical-id-set-diff-510
+                               (cdr lexical-exports-1182)
+                               lexical-defs-1183))))))
+             (lexical-check-module-exports-511
+              (lambda (lexical-source-exp-1184
+                       lexical-fexports-1185
+                       lexical-ids-1186)
+                (letrec* ((lexical-defined?-1187
+                           (lambda (lexical-e-1188 lexical-ids-1189)
+                             (ormap (lambda (lexical-x-1190)
+                                      (if (lexical-import-interface?-407
+                                           lexical-x-1190)
+                                          ((lambda (lexical-x.iface-1191
+                                                    lexical-x.new-marks-1192)
+                                             ((lambda (lexical-t-1193)
+                                                (if lexical-t-1193
+                                                    ((lambda (lexical-token-1194)
+                                                       (lexical-lookup-import-binding-name-442
+                                                        ((lambda (lexical-x-1195)
+                                                           ((lambda (lexical-e-1196)
+                                                              (if (lexical-annotation?-158
+                                                                   lexical-e-1196)
+                                                                  (annotation-expression
+                                                                   lexical-e-1196)
+                                                                  lexical-e-1196))
+                                                            (if (lexical-syntax-object?-90
+                                                                 lexical-x-1195)
+                                                                (lexical-syntax-object-expression-91
+                                                                 lexical-x-1195)
+                                                                lexical-x-1195)))
+                                                         lexical-e-1188)
+                                                        (lexical-id-marks-339
+                                                         lexical-e-1188)
+                                                        lexical-token-1194
+                                                        lexical-x.new-marks-1192))
+                                                     lexical-t-1193)
+                                                    ((lambda (lexical-v-1197)
+                                                       ((letrec ((lexical-lp-1198
+                                                                  (lambda (lexical-i-1199)
+                                                                    (if (>= lexical-i-1199
+                                                                            '0)
+                                                                        ((lambda (lexical-t-1200)
+                                                                           (if lexical-t-1200
+                                                                               lexical-t-1200
+                                                                               (lexical-lp-1198
+                                                                                (- lexical-i-1199
+                                                                                   '1))))
+                                                                         ((lambda (lexical-id-1201)
+                                                                            (lexical-help-bound-id=?-464
+                                                                             ((lambda (lexical-x-1202)
+                                                                                ((lambda (lexical-e-1203)
+                                                                                   (if (lexical-annotation?-158
+                                                                                        lexical-e-1203)
+                                                                                       (annotation-expression
+                                                                                        lexical-e-1203)
+                                                                                       lexical-e-1203))
+                                                                                 (if (lexical-syntax-object?-90
+                                                                                      lexical-x-1202)
+                                                                                     (lexical-syntax-object-expression-91
+                                                                                      lexical-x-1202)
+                                                                                     lexical-x-1202)))
+                                                                              lexical-id-1201)
+                                                                             (lexical-join-marks-450
+                                                                              lexical-x.new-marks-1192
+                                                                              (lexical-id-marks-339
+                                                                               lexical-id-1201))
+                                                                             ((lambda (lexical-x-1204)
+                                                                                ((lambda (lexical-e-1205)
+                                                                                   (if (lexical-annotation?-158
+                                                                                        lexical-e-1205)
+                                                                                       (annotation-expression
+                                                                                        lexical-e-1205)
+                                                                                       lexical-e-1205))
+                                                                                 (if (lexical-syntax-object?-90
+                                                                                      lexical-x-1204)
+                                                                                     (lexical-syntax-object-expression-91
+                                                                                      lexical-x-1204)
+                                                                                     lexical-x-1204)))
+                                                                              lexical-e-1188)
+                                                                             (lexical-id-marks-339
+                                                                              lexical-e-1188)))
+                                                                          (vector-ref
+                                                                           lexical-v-1197
+                                                                           lexical-i-1199)))
+                                                                        '#f))))
+                                                          lexical-lp-1198)
+                                                        (- (vector-length
+                                                            lexical-v-1197)
+                                                           '1)))
+                                                     (lexical-interface-exports-481
+                                                      lexical-x.iface-1191))))
+                                              (lexical-interface-token-482
+                                               lexical-x.iface-1191)))
+                                           (lexical-import-interface-interface-408
+                                            lexical-x-1190)
+                                           (lexical-import-interface-new-marks-409
+                                            lexical-x-1190))
+                                          (lexical-bound-id=?-465
+                                           lexical-e-1188
+                                           lexical-x-1190)))
+                                    lexical-ids-1189))))
+                  ((letrec ((lexical-loop-1206
+                             (lambda (lexical-fexports-1207
+                                      lexical-missing-1208)
+                               (if (null? lexical-fexports-1207)
+                                   (if (not (null? lexical-missing-1208))
+                                       (syntax-error
+                                        (car lexical-missing-1208)
+                                        (if (= (length lexical-missing-1208)
+                                               '1)
+                                            '"missing definition for export"
+                                            '"missing definition for multiple exports, including"))
+                                       (void))
+                                   ((lambda (lexical-e-1209
+                                             lexical-fexports-1210)
+                                      (if (lexical-defined?-1187
+                                           lexical-e-1209
+                                           lexical-ids-1186)
+                                          (lexical-loop-1206
+                                           lexical-fexports-1210
+                                           lexical-missing-1208)
+                                          (lexical-loop-1206
+                                           lexical-fexports-1210
+                                           (cons lexical-e-1209
+                                                 lexical-missing-1208))))
+                                    (car lexical-fexports-1207)
+                                    (cdr lexical-fexports-1207))))))
+                     lexical-loop-1206)
+                   lexical-fexports-1185
+                   '()))))
+             (lexical-check-defined-ids-512
+              (lambda (lexical-source-exp-1211 lexical-ls-1212)
+                (letrec* ((lexical-vfold-1213
+                           (lambda (lexical-v-1216
+                                    lexical-p-1217
+                                    lexical-cls-1218)
+                             ((lambda (lexical-len-1219)
+                                ((letrec ((lexical-lp-1220
+                                           (lambda (lexical-i-1221
+                                                    lexical-cls-1222)
+                                             (if (= lexical-i-1221
+                                                    lexical-len-1219)
+                                                 lexical-cls-1222
+                                                 (lexical-lp-1220
+                                                  (+ lexical-i-1221 '1)
+                                                  (lexical-p-1217
+                                                   (vector-ref
+                                                    lexical-v-1216
+                                                    lexical-i-1221)
+                                                   lexical-cls-1222))))))
+                                   lexical-lp-1220)
+                                 '0
+                                 lexical-cls-1218))
+                              (vector-length lexical-v-1216))))
+                          (lexical-conflicts-1214
+                           (lambda (lexical-x-1223
+                                    lexical-y-1224
+                                    lexical-cls-1225)
+                             (if (lexical-import-interface?-407 lexical-x-1223)
+                                 ((lambda (lexical-x.iface-1226
+                                           lexical-x.new-marks-1227)
+                                    (if (lexical-import-interface?-407
+                                         lexical-y-1224)
+                                        ((lambda (lexical-y.iface-1228
+                                                  lexical-y.new-marks-1229)
+                                           ((lambda (lexical-xe-1230
+                                                     lexical-ye-1231)
+                                              (if (> (vector-length
+                                                      lexical-xe-1230)
+                                                     (vector-length
+                                                      lexical-ye-1231))
+                                                  (lexical-vfold-1213
+                                                   lexical-ye-1231
+                                                   (lambda (lexical-id-1232
+                                                            lexical-cls-1233)
+                                                     (lexical-id-iface-conflicts-1215
+                                                      lexical-id-1232
+                                                      lexical-y.new-marks-1229
+                                                      lexical-x.iface-1226
+                                                      lexical-x.new-marks-1227
+                                                      lexical-cls-1233))
+                                                   lexical-cls-1225)
+                                                  (lexical-vfold-1213
+                                                   lexical-xe-1230
+                                                   (lambda (lexical-id-1234
+                                                            lexical-cls-1235)
+                                                     (lexical-id-iface-conflicts-1215
+                                                      lexical-id-1234
+                                                      lexical-x.new-marks-1227
+                                                      lexical-y.iface-1228
+                                                      lexical-y.new-marks-1229
+                                                      lexical-cls-1235))
+                                                   lexical-cls-1225)))
+                                            (lexical-interface-exports-481
+                                             lexical-x.iface-1226)
+                                            (lexical-interface-exports-481
+                                             lexical-y.iface-1228)))
+                                         (lexical-import-interface-interface-408
+                                          lexical-y-1224)
+                                         (lexical-import-interface-new-marks-409
+                                          lexical-y-1224))
+                                        (lexical-id-iface-conflicts-1215
+                                         lexical-y-1224
+                                         '()
+                                         lexical-x.iface-1226
+                                         lexical-x.new-marks-1227
+                                         lexical-cls-1225)))
+                                  (lexical-import-interface-interface-408
+                                   lexical-x-1223)
+                                  (lexical-import-interface-new-marks-409
+                                   lexical-x-1223))
+                                 (if (lexical-import-interface?-407
+                                      lexical-y-1224)
+                                     ((lambda (lexical-y.iface-1236
+                                               lexical-y.new-marks-1237)
+                                        (lexical-id-iface-conflicts-1215
+                                         lexical-x-1223
+                                         '()
+                                         lexical-y.iface-1236
+                                         lexical-y.new-marks-1237
+                                         lexical-cls-1225))
+                                      (lexical-import-interface-interface-408
+                                       lexical-y-1224)
+                                      (lexical-import-interface-new-marks-409
+                                       lexical-y-1224))
+                                     (if (lexical-bound-id=?-465
+                                          lexical-x-1223
+                                          lexical-y-1224)
+                                         (cons lexical-x-1223 lexical-cls-1225)
+                                         lexical-cls-1225)))))
+                          (lexical-id-iface-conflicts-1215
+                           (lambda (lexical-id-1238
+                                    lexical-id.new-marks-1239
+                                    lexical-iface-1240
+                                    lexical-iface.new-marks-1241
+                                    lexical-cls-1242)
+                             ((lambda (lexical-id.sym-1243
+                                       lexical-id.marks-1244
+                                       lexical-id.label-1245)
+                                ((lambda (lexical-t-1246)
+                                   (if lexical-t-1246
+                                       ((lambda (lexical-token-1247)
+                                          ((lambda (lexical-found-label-1248)
+                                             (if (if lexical-found-label-1248
+                                                     (not (eq? lexical-found-label-1248
+                                                               lexical-id.label-1245))
+                                                     '#f)
+                                                 (cons lexical-id-1238
+                                                       lexical-cls-1242)
+                                                 lexical-cls-1242))
+                                           (lexical-lookup-import-binding-name-442
+                                            lexical-id.sym-1243
+                                            lexical-id.marks-1244
+                                            lexical-token-1247
+                                            lexical-iface.new-marks-1241)))
+                                        lexical-t-1246)
+                                       (lexical-vfold-1213
+                                        (lexical-interface-exports-481
+                                         lexical-iface-1240)
+                                        (lambda (lexical-*id-1249
+                                                 lexical-cls-1250)
+                                          ((lambda (lexical-*id.sym-1251
+                                                    lexical-*id.marks-1252
+                                                    lexical-*id.label-1253)
+                                             (if (if (lexical-help-bound-id=?-464
+                                                      lexical-*id.sym-1251
+                                                      lexical-*id.marks-1252
+                                                      lexical-id.sym-1243
+                                                      lexical-id.marks-1244)
+                                                     (not (eq? lexical-*id.label-1253
+                                                               lexical-id.label-1245))
+                                                     '#f)
+                                                 (cons lexical-*id-1249
+                                                       lexical-cls-1250)
+                                                 lexical-cls-1250))
+                                           ((lambda (lexical-x-1254)
+                                              ((lambda (lexical-e-1255)
+                                                 (if (lexical-annotation?-158
+                                                      lexical-e-1255)
+                                                     (annotation-expression
+                                                      lexical-e-1255)
+                                                     lexical-e-1255))
+                                               (if (lexical-syntax-object?-90
+                                                    lexical-x-1254)
+                                                   (lexical-syntax-object-expression-91
+                                                    lexical-x-1254)
+                                                   lexical-x-1254)))
+                                            lexical-*id-1249)
+                                           (lexical-join-marks-450
+                                            lexical-iface.new-marks-1241
+                                            (lexical-id-marks-339
+                                             lexical-*id-1249))
+                                           (lexical-id-var-name-461
+                                            lexical-*id-1249
+                                            '(()))))
+                                        lexical-cls-1242)))
+                                 (lexical-interface-token-482
+                                  lexical-iface-1240)))
+                              ((lambda (lexical-x-1256)
+                                 ((lambda (lexical-e-1257)
+                                    (if (lexical-annotation?-158
+                                         lexical-e-1257)
+                                        (annotation-expression lexical-e-1257)
+                                        lexical-e-1257))
+                                  (if (lexical-syntax-object?-90
+                                       lexical-x-1256)
+                                      (lexical-syntax-object-expression-91
+                                       lexical-x-1256)
+                                      lexical-x-1256)))
+                               lexical-id-1238)
+                              (lexical-join-marks-450
+                               lexical-id.new-marks-1239
+                               (lexical-id-marks-339 lexical-id-1238))
+                              (lexical-id-var-name-461 lexical-id-1238 '(()))))))
+                  (if (not (null? lexical-ls-1212))
+                      ((letrec ((lexical-lp-1258
+                                 (lambda (lexical-x-1259
+                                          lexical-ls-1260
+                                          lexical-cls-1261)
+                                   (if (null? lexical-ls-1260)
+                                       (if (not (null? lexical-cls-1261))
+                                           ((lambda (lexical-cls-1262)
+                                              (syntax-error
+                                               lexical-source-exp-1211
+                                               '"duplicate definition for "
+                                               (symbol->string
+                                                (car lexical-cls-1262))
+                                               '" in"))
+                                            (syntax-object->datum
+                                             lexical-cls-1261))
+                                           (void))
+                                       ((letrec ((lexical-lp2-1263
+                                                  (lambda (lexical-ls2-1264
+                                                           lexical-cls-1265)
+                                                    (if (null? lexical-ls2-1264)
+                                                        (lexical-lp-1258
+                                                         (car lexical-ls-1260)
+                                                         (cdr lexical-ls-1260)
+                                                         lexical-cls-1265)
+                                                        (lexical-lp2-1263
+                                                         (cdr lexical-ls2-1264)
+                                                         (lexical-conflicts-1214
+                                                          lexical-x-1259
+                                                          (car lexical-ls2-1264)
+                                                          lexical-cls-1265))))))
+                                          lexical-lp2-1263)
+                                        lexical-ls-1260
+                                        lexical-cls-1261)))))
+                         lexical-lp-1258)
+                       (car lexical-ls-1212)
+                       (cdr lexical-ls-1212)
+                       '())
+                      (void)))))
+             (lexical-chi-external-513
+              (lambda (lexical-ribcage-1266
+                       lexical-source-exp-1267
+                       lexical-body-1268
+                       lexical-r-1269
+                       lexical-mr-1270
+                       lexical-ctem-1271
+                       lexical-exports-1272
+                       lexical-fexports-1273
+                       lexical-meta-residualize!-1274)
+                (letrec* ((lexical-return-1275
+                           (lambda (lexical-r-1278
+                                    lexical-mr-1279
+                                    lexical-bindings-1280
+                                    lexical-ids-1281
+                                    lexical-inits-1282)
+                             (begin
+                               (lexical-check-defined-ids-512
+                                lexical-source-exp-1267
+                                lexical-ids-1281)
+                               (lexical-check-module-exports-511
+                                lexical-source-exp-1267
+                                lexical-fexports-1273
+                                lexical-ids-1281)
+                               (values
+                                lexical-r-1278
+                                lexical-mr-1279
+                                lexical-bindings-1280
+                                lexical-inits-1282))))
+                          (lexical-get-implicit-exports-1276
+                           (lambda (lexical-id-1283)
+                             ((letrec ((lexical-f-1284
+                                        (lambda (lexical-exports-1285)
+                                          (if (null? lexical-exports-1285)
+                                              '()
+                                              (if (if (pair? (car lexical-exports-1285))
+                                                      (lexical-bound-id=?-465
+                                                       lexical-id-1283
+                                                       (caar lexical-exports-1285))
+                                                      '#f)
+                                                  (lexical-flatten-exports-477
+                                                   (cdar lexical-exports-1285))
+                                                  (lexical-f-1284
+                                                   (cdr lexical-exports-1285)))))))
+                                lexical-f-1284)
+                              lexical-exports-1272)))
+                          (lexical-update-imp-exports-1277
+                           (lambda (lexical-bindings-1286 lexical-exports-1287)
+                             ((lambda (lexical-exports-1288)
+                                (map (lambda (lexical-b-1289)
+                                       ((lambda (lexical-id-1290)
+                                          (if (not (lexical-bound-id-member?-469
+                                                    lexical-id-1290
+                                                    lexical-exports-1288))
+                                              lexical-b-1289
+                                              (lexical-create-module-binding-502
+                                               (lexical-module-binding-type-490
+                                                lexical-b-1289)
+                                               lexical-id-1290
+                                               (lexical-module-binding-label-492
+                                                lexical-b-1289)
+                                               (append
+                                                (lexical-get-implicit-exports-1276
+                                                 lexical-id-1290)
+                                                (lexical-module-binding-imps-493
+                                                 lexical-b-1289))
+                                               (lexical-module-binding-val-494
+                                                lexical-b-1289))))
+                                        (lexical-module-binding-id-491
+                                         lexical-b-1289)))
+                                     lexical-bindings-1286))
+                              (map (lambda (lexical-x-1291)
+                                     (if (pair? lexical-x-1291)
+                                         (car lexical-x-1291)
+                                         lexical-x-1291))
+                                   lexical-exports-1287)))))
+                  ((letrec ((lexical-parse-1292
+                             (lambda (lexical-body-1293
+                                      lexical-r-1294
+                                      lexical-mr-1295
+                                      lexical-ids-1296
+                                      lexical-bindings-1297
+                                      lexical-inits-1298
+                                      lexical-meta-seen?-1299)
+                               (if (null? lexical-body-1293)
+                                   (lexical-return-1275
+                                    lexical-r-1294
+                                    lexical-mr-1295
+                                    lexical-bindings-1297
+                                    lexical-ids-1296
+                                    lexical-inits-1298)
+                                   ((lambda (lexical-fr-1300)
+                                      ((lambda (lexical-e-1301)
+                                         ((lambda (lexical-meta?-1302)
+                                            ((lambda ()
+                                               (call-with-values
+                                                (lambda ()
+                                                  (lexical-syntax-type-473
+                                                   lexical-e-1301
+                                                   lexical-r-1294
+                                                   '(())
+                                                   '#f
+                                                   lexical-ribcage-1266))
+                                                (lambda (lexical-type-1303
+                                                         lexical-value-1304
+                                                         lexical-e-1305
+                                                         lexical-w-1306
+                                                         lexical-ae-1307)
+                                                  ((lambda (lexical-t-1308)
+                                                     (if (memv lexical-t-1308
+                                                               '(define-form))
+                                                         (call-with-values
+                                                          (lambda ()
+                                                            (lexical-parse-define-538
+                                                             lexical-e-1305
+                                                             lexical-w-1306
+                                                             lexical-ae-1307))
+                                                          (lambda (lexical-id-1309
+                                                                   lexical-rhs-1310
+                                                                   lexical-w-1311)
+                                                            ((lambda (lexical-id-1312)
+                                                               ((lambda (lexical-label-1313)
+                                                                  ((lambda (lexical-imps-1314)
+                                                                     ((lambda ()
+                                                                        (begin
+                                                                          (lexical-extend-ribcage!-437
+                                                                           lexical-ribcage-1266
+                                                                           lexical-id-1312
+                                                                           lexical-label-1313)
+                                                                          (if lexical-meta?-1302
+                                                                              ((lambda (lexical-sym-1315)
+                                                                                 ((lambda (lexical-b-1316)
+                                                                                    ((lambda ()
+                                                                                       ((lambda (lexical-mr-1317)
+                                                                                          ((lambda (lexical-exp-1318)
+                                                                                             (begin
+                                                                                               (lexical-define-top-level-value-hook-161
+                                                                                                lexical-sym-1315
+                                                                                                (lexical-top-level-eval-hook-159
+                                                                                                 lexical-exp-1318))
+                                                                                               (lexical-meta-residualize!-1274
+                                                                                                (lexical-ct-eval/residualize3-521
+                                                                                                 lexical-ctem-1271
+                                                                                                 void
+                                                                                                 (lambda ()
+                                                                                                   (list 'define
+                                                                                                         lexical-sym-1315
+                                                                                                         lexical-exp-1318))))
+                                                                                               (lexical-parse-1292
+                                                                                                (cdr lexical-body-1293)
+                                                                                                lexical-r-1294
+                                                                                                lexical-mr-1317
+                                                                                                (cons lexical-id-1312
+                                                                                                      lexical-ids-1296)
+                                                                                                (cons (lexical-create-module-binding-502
+                                                                                                       'ctdefine-form
+                                                                                                       lexical-id-1312
+                                                                                                       lexical-label-1313
+                                                                                                       lexical-imps-1314
+                                                                                                       lexical-b-1316)
+                                                                                                      lexical-bindings-1297)
+                                                                                                lexical-inits-1298
+                                                                                                '#f)))
+                                                                                           (lexical-chi-525
+                                                                                            lexical-rhs-1310
+                                                                                            lexical-mr-1317
+                                                                                            lexical-mr-1317
+                                                                                            lexical-w-1311
+                                                                                            '#t)))
+                                                                                        (lexical-extend-env-322
+                                                                                         (lexical-get-indirect-label-387
+                                                                                          lexical-label-1313)
+                                                                                         lexical-b-1316
+                                                                                         lexical-mr-1295)))))
+                                                                                  (cons 'meta-variable
+                                                                                        lexical-sym-1315)))
+                                                                               (lexical-generate-id-169
+                                                                                ((lambda (lexical-x-1319)
+                                                                                   ((lambda (lexical-e-1320)
+                                                                                      (if (lexical-annotation?-158
+                                                                                           lexical-e-1320)
+                                                                                          (annotation-expression
+                                                                                           lexical-e-1320)
+                                                                                          lexical-e-1320))
+                                                                                    (if (lexical-syntax-object?-90
+                                                                                         lexical-x-1319)
+                                                                                        (lexical-syntax-object-expression-91
+                                                                                         lexical-x-1319)
+                                                                                        lexical-x-1319)))
+                                                                                 lexical-id-1312)))
+                                                                              (lexical-parse-1292
+                                                                               (cdr lexical-body-1293)
+                                                                               lexical-r-1294
+                                                                               lexical-mr-1295
+                                                                               (cons lexical-id-1312
+                                                                                     lexical-ids-1296)
+                                                                               (cons (lexical-create-module-binding-502
+                                                                                      lexical-type-1303
+                                                                                      lexical-id-1312
+                                                                                      lexical-label-1313
+                                                                                      lexical-imps-1314
+                                                                                      (lexical-make-frob-503
+                                                                                       (lexical-wrap-470
+                                                                                        lexical-rhs-1310
+                                                                                        lexical-w-1311)
+                                                                                       lexical-meta?-1302))
+                                                                                     lexical-bindings-1297)
+                                                                               lexical-inits-1298
+                                                                               '#f))))))
+                                                                   (lexical-get-implicit-exports-1276
+                                                                    lexical-id-1312)))
+                                                                (lexical-gen-indirect-label-386)))
+                                                             (lexical-wrap-470
+                                                              lexical-id-1309
+                                                              lexical-w-1311))))
+                                                         (if (memv lexical-t-1308
+                                                                   '(define-syntax-form))
+                                                             (call-with-values
+                                                              (lambda ()
+                                                                (lexical-parse-define-syntax-539
+                                                                 lexical-e-1305
+                                                                 lexical-w-1306
+                                                                 lexical-ae-1307))
+                                                              (lambda (lexical-id-1321
+                                                                       lexical-rhs-1322
+                                                                       lexical-w-1323)
+                                                                ((lambda (lexical-id-1324)
+                                                                   ((lambda (lexical-label-1325)
+                                                                      ((lambda (lexical-imps-1326)
+                                                                         ((lambda (lexical-exp-1327)
+                                                                            ((lambda ()
+                                                                               (begin
+                                                                                 (lexical-extend-ribcage!-437
+                                                                                  lexical-ribcage-1266
+                                                                                  lexical-id-1324
+                                                                                  lexical-label-1325)
+                                                                                 ((lambda (lexical-l-1328
+                                                                                           lexical-b-1329)
+                                                                                    (lexical-parse-1292
+                                                                                     (cdr lexical-body-1293)
+                                                                                     (lexical-extend-env-322
+                                                                                      lexical-l-1328
+                                                                                      lexical-b-1329
+                                                                                      lexical-r-1294)
+                                                                                     (lexical-extend-env-322
+                                                                                      lexical-l-1328
+                                                                                      lexical-b-1329
+                                                                                      lexical-mr-1295)
+                                                                                     (cons lexical-id-1324
+                                                                                           lexical-ids-1296)
+                                                                                     (cons (lexical-create-module-binding-502
+                                                                                            lexical-type-1303
+                                                                                            lexical-id-1324
+                                                                                            lexical-label-1325
+                                                                                            lexical-imps-1326
+                                                                                            (cons lexical-b-1329
+                                                                                                  lexical-exp-1327))
+                                                                                           lexical-bindings-1297)
+                                                                                     lexical-inits-1298
+                                                                                     '#f))
+                                                                                  (lexical-get-indirect-label-387
+                                                                                   lexical-label-1325)
+                                                                                  (lexical-defer-or-eval-transformer-330
+                                                                                   lexical-top-level-eval-hook-159
+                                                                                   lexical-exp-1327))))))
+                                                                          (lexical-chi-525
+                                                                           lexical-rhs-1322
+                                                                           lexical-mr-1295
+                                                                           lexical-mr-1295
+                                                                           lexical-w-1323
+                                                                           '#t)))
+                                                                       (lexical-get-implicit-exports-1276
+                                                                        lexical-id-1324)))
+                                                                    (lexical-gen-indirect-label-386)))
+                                                                 (lexical-wrap-470
+                                                                  lexical-id-1321
+                                                                  lexical-w-1323))))
+                                                             (if (memv lexical-t-1308
+                                                                       '($module-form))
+                                                                 ((lambda (lexical-*ribcage-1330)
+                                                                    ((lambda (lexical-*w-1331)
+                                                                       ((lambda ()
+                                                                          (call-with-values
+                                                                           (lambda ()
+                                                                             (lexical-parse-module-536
+                                                                              lexical-e-1305
+                                                                              lexical-w-1306
+                                                                              lexical-ae-1307
+                                                                              lexical-*w-1331))
+                                                                           (lambda (lexical-orig-1332
+                                                                                    lexical-id-1333
+                                                                                    lexical-*exports-1334
+                                                                                    lexical-forms-1335)
+                                                                             (call-with-values
+                                                                              (lambda ()
+                                                                                (lexical-chi-external-513
+                                                                                 lexical-*ribcage-1330
+                                                                                 lexical-orig-1332
+                                                                                 (map (lambda (lexical-d-1336)
+                                                                                        (lexical-make-frob-503
+                                                                                         lexical-d-1336
+                                                                                         lexical-meta?-1302))
+                                                                                      lexical-forms-1335)
+                                                                                 lexical-r-1294
+                                                                                 lexical-mr-1295
+                                                                                 lexical-ctem-1271
+                                                                                 lexical-*exports-1334
+                                                                                 (lexical-flatten-exports-477
+                                                                                  lexical-*exports-1334)
+                                                                                 lexical-meta-residualize!-1274))
+                                                                              (lambda (lexical-r-1337
+                                                                                       lexical-mr-1338
+                                                                                       lexical-*bindings-1339
+                                                                                       lexical-*inits-1340)
+                                                                                ((lambda (lexical-iface-1341
+                                                                                          lexical-bindings-1342
+                                                                                          lexical-inits-1343
+                                                                                          lexical-label-1344
+                                                                                          lexical-imps-1345)
+                                                                                   (begin
+                                                                                     (lexical-extend-ribcage!-437
+                                                                                      lexical-ribcage-1266
+                                                                                      lexical-id-1333
+                                                                                      lexical-label-1344)
+                                                                                     ((lambda (lexical-l-1346
+                                                                                               lexical-b-1347)
+                                                                                        (lexical-parse-1292
+                                                                                         (cdr lexical-body-1293)
+                                                                                         (lexical-extend-env-322
+                                                                                          lexical-l-1346
+                                                                                          lexical-b-1347
+                                                                                          lexical-r-1337)
+                                                                                         (lexical-extend-env-322
+                                                                                          lexical-l-1346
+                                                                                          lexical-b-1347
+                                                                                          lexical-mr-1338)
+                                                                                         (cons lexical-id-1333
+                                                                                               lexical-ids-1296)
+                                                                                         (cons (lexical-create-module-binding-502
+                                                                                                lexical-type-1303
+                                                                                                lexical-id-1333
+                                                                                                lexical-label-1344
+                                                                                                lexical-imps-1345
+                                                                                                lexical-*exports-1334)
+                                                                                               lexical-bindings-1342)
+                                                                                         lexical-inits-1343
+                                                                                         '#f))
+                                                                                      (lexical-get-indirect-label-387
+                                                                                       lexical-label-1344)
+                                                                                      (cons '$module
+                                                                                            lexical-iface-1341))))
+                                                                                 (lexical-make-unresolved-interface-486
+                                                                                  lexical-id-1333
+                                                                                  lexical-*exports-1334)
+                                                                                 (append
+                                                                                  lexical-*bindings-1339
+                                                                                  lexical-bindings-1297)
+                                                                                 (append
+                                                                                  lexical-inits-1298
+                                                                                  lexical-*inits-1340)
+                                                                                 (lexical-gen-indirect-label-386)
+                                                                                 (lexical-get-implicit-exports-1276
+                                                                                  lexical-id-1333)))))))))
+                                                                     (lexical-make-wrap-342
+                                                                      (lexical-wrap-marks-343
+                                                                       lexical-w-1306)
+                                                                      (cons lexical-*ribcage-1330
+                                                                            (lexical-wrap-subst-344
+                                                                             lexical-w-1306)))))
+                                                                  (lexical-make-ribcage-392
+                                                                   '()
+                                                                   '()
+                                                                   '()))
+                                                                 (if (memv lexical-t-1308
+                                                                           '($import-form))
+                                                                     (call-with-values
+                                                                      (lambda ()
+                                                                        (lexical-parse-import-537
+                                                                         lexical-e-1305
+                                                                         lexical-w-1306
+                                                                         lexical-ae-1307))
+                                                                      (lambda (lexical-orig-1348
+                                                                               lexical-only?-1349
+                                                                               lexical-mid-1350)
+                                                                        ((lambda (lexical-mlabel-1351)
+                                                                           ((lambda (lexical-binding-1352)
+                                                                              ((lambda (lexical-t-1353)
+                                                                                 (if (memv lexical-t-1353
+                                                                                           '($module))
+                                                                                     ((lambda (lexical-iface-1354)
+                                                                                        ((lambda (lexical-import-iface-1355)
+                                                                                           ((lambda ()
+                                                                                              (begin
+                                                                                                (if lexical-only?-1349
+                                                                                                    (lexical-extend-ribcage-barrier!-439
+                                                                                                     lexical-ribcage-1266
+                                                                                                     lexical-mid-1350)
+                                                                                                    (void))
+                                                                                                (lexical-do-import!-535
+                                                                                                 lexical-import-iface-1355
+                                                                                                 lexical-ribcage-1266)
+                                                                                                (lexical-parse-1292
+                                                                                                 (cdr lexical-body-1293)
+                                                                                                 lexical-r-1294
+                                                                                                 lexical-mr-1295
+                                                                                                 (cons lexical-import-iface-1355
+                                                                                                       lexical-ids-1296)
+                                                                                                 (lexical-update-imp-exports-1277
+                                                                                                  lexical-bindings-1297
+                                                                                                  (vector->list
+                                                                                                   (lexical-interface-exports-481
+                                                                                                    lexical-iface-1354)))
+                                                                                                 lexical-inits-1298
+                                                                                                 '#f)))))
+                                                                                         (lexical-make-import-interface-406
+                                                                                          lexical-iface-1354
+                                                                                          (lexical-import-mark-delta-533
+                                                                                           lexical-mid-1350
+                                                                                           lexical-iface-1354))))
+                                                                                      (lexical-binding-value-309
+                                                                                       lexical-binding-1352))
+                                                                                     (if (memv lexical-t-1353
+                                                                                               '(displaced-lexical))
+                                                                                         (lexical-displaced-lexical-error-326
+                                                                                          lexical-mid-1350)
+                                                                                         (syntax-error
+                                                                                          lexical-mid-1350
+                                                                                          '"unknown module"))))
+                                                                               (lexical-binding-type-308
+                                                                                lexical-binding-1352)))
+                                                                            (lexical-lookup-328
+                                                                             lexical-mlabel-1351
+                                                                             lexical-r-1294)))
+                                                                         (lexical-id-var-name-461
+                                                                          lexical-mid-1350
+                                                                          '(())))))
+                                                                     (if (memv lexical-t-1308
+                                                                               '(alias-form))
+                                                                         (call-with-values
+                                                                          (lambda ()
+                                                                            (lexical-parse-alias-542
+                                                                             lexical-e-1305
+                                                                             lexical-w-1306
+                                                                             lexical-ae-1307))
+                                                                          (lambda (lexical-new-id-1356
+                                                                                   lexical-old-id-1357)
+                                                                            ((lambda (lexical-new-id-1358)
+                                                                               ((lambda (lexical-label-1359)
+                                                                                  ((lambda (lexical-imps-1360)
+                                                                                     ((lambda ()
+                                                                                        (begin
+                                                                                          (lexical-extend-ribcage!-437
+                                                                                           lexical-ribcage-1266
+                                                                                           lexical-new-id-1358
+                                                                                           lexical-label-1359)
+                                                                                          (lexical-parse-1292
+                                                                                           (cdr lexical-body-1293)
+                                                                                           lexical-r-1294
+                                                                                           lexical-mr-1295
+                                                                                           (cons lexical-new-id-1358
+                                                                                                 lexical-ids-1296)
+                                                                                           (cons (lexical-create-module-binding-502
+                                                                                                  lexical-type-1303
+                                                                                                  lexical-new-id-1358
+                                                                                                  lexical-label-1359
+                                                                                                  lexical-imps-1360
+                                                                                                  '#f)
+                                                                                                 lexical-bindings-1297)
+                                                                                           lexical-inits-1298
+                                                                                           '#f)))))
+                                                                                   (lexical-get-implicit-exports-1276
+                                                                                    lexical-new-id-1358)))
+                                                                                (lexical-id-var-name-loc-460
+                                                                                 lexical-old-id-1357
+                                                                                 lexical-w-1306)))
+                                                                             (lexical-wrap-470
+                                                                              lexical-new-id-1356
+                                                                              lexical-w-1306))))
+                                                                         (if (memv lexical-t-1308
+                                                                                   '(begin-form))
+                                                                             (lexical-parse-1292
+                                                                              ((letrec ((lexical-f-1361
+                                                                                         (lambda (lexical-forms-1362)
+                                                                                           (if (null? lexical-forms-1362)
+                                                                                               (cdr lexical-body-1293)
+                                                                                               (cons (lexical-make-frob-503
+                                                                                                      (lexical-wrap-470
+                                                                                                       (car lexical-forms-1362)
+                                                                                                       lexical-w-1306)
+                                                                                                      lexical-meta?-1302)
+                                                                                                     (lexical-f-1361
+                                                                                                      (cdr lexical-forms-1362)))))))
+                                                                                 lexical-f-1361)
+                                                                               (lexical-parse-begin-543
+                                                                                lexical-e-1305
+                                                                                lexical-w-1306
+                                                                                lexical-ae-1307
+                                                                                '#t))
+                                                                              lexical-r-1294
+                                                                              lexical-mr-1295
+                                                                              lexical-ids-1296
+                                                                              lexical-bindings-1297
+                                                                              lexical-inits-1298
+                                                                              '#f)
+                                                                             (if (memv lexical-t-1308
+                                                                                       '(eval-when-form))
+                                                                                 (call-with-values
+                                                                                  (lambda ()
+                                                                                    (lexical-parse-eval-when-541
+                                                                                     lexical-e-1305
+                                                                                     lexical-w-1306
+                                                                                     lexical-ae-1307))
+                                                                                  (lambda (lexical-when-list-1363
+                                                                                           lexical-forms-1364)
+                                                                                    (lexical-parse-1292
+                                                                                     (if (memq 'eval
+                                                                                               lexical-when-list-1363)
+                                                                                         ((letrec ((lexical-f-1365
+                                                                                                    (lambda (lexical-forms-1366)
+                                                                                                      (if (null? lexical-forms-1366)
+                                                                                                          (cdr lexical-body-1293)
+                                                                                                          (cons (lexical-make-frob-503
+                                                                                                                 (lexical-wrap-470
+                                                                                                                  (car lexical-forms-1366)
+                                                                                                                  lexical-w-1306)
+                                                                                                                 lexical-meta?-1302)
+                                                                                                                (lexical-f-1365
+                                                                                                                 (cdr lexical-forms-1366)))))))
+                                                                                            lexical-f-1365)
+                                                                                          lexical-forms-1364)
+                                                                                         (cdr lexical-body-1293))
+                                                                                     lexical-r-1294
+                                                                                     lexical-mr-1295
+                                                                                     lexical-ids-1296
+                                                                                     lexical-bindings-1297
+                                                                                     lexical-inits-1298
+                                                                                     '#f)))
+                                                                                 (if (memv lexical-t-1308
+                                                                                           '(meta-form))
+                                                                                     (lexical-parse-1292
+                                                                                      (cons (lexical-make-frob-503
+                                                                                             (lexical-wrap-470
+                                                                                              (lexical-parse-meta-540
+                                                                                               lexical-e-1305
+                                                                                               lexical-w-1306
+                                                                                               lexical-ae-1307)
+                                                                                              lexical-w-1306)
+                                                                                             '#t)
+                                                                                            (cdr lexical-body-1293))
+                                                                                      lexical-r-1294
+                                                                                      lexical-mr-1295
+                                                                                      lexical-ids-1296
+                                                                                      lexical-bindings-1297
+                                                                                      lexical-inits-1298
+                                                                                      '#t)
+                                                                                     (if (memv lexical-t-1308
+                                                                                               '(local-syntax-form))
+                                                                                         (call-with-values
+                                                                                          (lambda ()
+                                                                                            (lexical-chi-local-syntax-545
+                                                                                             lexical-value-1304
+                                                                                             lexical-e-1305
+                                                                                             lexical-r-1294
+                                                                                             lexical-mr-1295
+                                                                                             lexical-w-1306
+                                                                                             lexical-ae-1307))
+                                                                                          (lambda (lexical-forms-1367
+                                                                                                   lexical-r-1368
+                                                                                                   lexical-mr-1369
+                                                                                                   lexical-w-1370
+                                                                                                   lexical-ae-1371)
+                                                                                            (lexical-parse-1292
+                                                                                             ((letrec ((lexical-f-1372
+                                                                                                        (lambda (lexical-forms-1373)
+                                                                                                          (if (null? lexical-forms-1373)
+                                                                                                              (cdr lexical-body-1293)
+                                                                                                              (cons (lexical-make-frob-503
+                                                                                                                     (lexical-wrap-470
+                                                                                                                      (car lexical-forms-1373)
+                                                                                                                      lexical-w-1370)
+                                                                                                                     lexical-meta?-1302)
+                                                                                                                    (lexical-f-1372
+                                                                                                                     (cdr lexical-forms-1373)))))))
+                                                                                                lexical-f-1372)
+                                                                                              lexical-forms-1367)
+                                                                                             lexical-r-1368
+                                                                                             lexical-mr-1369
+                                                                                             lexical-ids-1296
+                                                                                             lexical-bindings-1297
+                                                                                             lexical-inits-1298
+                                                                                             '#f)))
+                                                                                         (begin
+                                                                                           (if lexical-meta-seen?-1299
+                                                                                               (syntax-error
+                                                                                                (lexical-source-wrap-471
+                                                                                                 lexical-e-1305
+                                                                                                 lexical-w-1306
+                                                                                                 lexical-ae-1307)
+                                                                                                '"invalid meta definition")
+                                                                                               (void))
+                                                                                           ((letrec ((lexical-f-1374
+                                                                                                      (lambda (lexical-body-1375)
+                                                                                                        (if ((lambda (lexical-t-1376)
+                                                                                                               (if lexical-t-1376
+                                                                                                                   lexical-t-1376
+                                                                                                                   (not (lexical-frob-meta?-506
+                                                                                                                         (car lexical-body-1375)))))
+                                                                                                             (null? lexical-body-1375))
+                                                                                                            (lexical-return-1275
+                                                                                                             lexical-r-1294
+                                                                                                             lexical-mr-1295
+                                                                                                             lexical-bindings-1297
+                                                                                                             lexical-ids-1296
+                                                                                                             (append
+                                                                                                              lexical-inits-1298
+                                                                                                              lexical-body-1375))
+                                                                                                            (begin
+                                                                                                              ((lambda (lexical-x-1377)
+                                                                                                                 (begin
+                                                                                                                   (lexical-top-level-eval-hook-159
+                                                                                                                    lexical-x-1377)
+                                                                                                                   (lexical-meta-residualize!-1274
+                                                                                                                    (lexical-ct-eval/residualize3-521
+                                                                                                                     lexical-ctem-1271
+                                                                                                                     void
+                                                                                                                     (lambda ()
+                                                                                                                       lexical-x-1377)))))
+                                                                                                               (lexical-chi-meta-frob-523
+                                                                                                                (car lexical-body-1375)
+                                                                                                                lexical-mr-1295))
+                                                                                                              (lexical-f-1374
+                                                                                                               (cdr lexical-body-1375)))))))
+                                                                                              lexical-f-1374)
+                                                                                            (cons (lexical-make-frob-503
+                                                                                                   (lexical-source-wrap-471
+                                                                                                    lexical-e-1305
+                                                                                                    lexical-w-1306
+                                                                                                    lexical-ae-1307)
+                                                                                                   lexical-meta?-1302)
+                                                                                                  (cdr lexical-body-1293))))))))))))))
+                                                   lexical-type-1303))))))
+                                          (lexical-frob-meta?-506
+                                           lexical-fr-1300)))
+                                       (lexical-frob-e-505 lexical-fr-1300)))
+                                    (car lexical-body-1293))))))
+                     lexical-parse-1292)
+                   lexical-body-1268
+                   lexical-r-1269
+                   lexical-mr-1270
+                   '()
+                   '()
+                   '()
+                   '#f))))
+             (lexical-vmap-514
+              (lambda (lexical-fn-1378 lexical-v-1379)
+                ((letrec ((lexical-do-1380
+                           (lambda (lexical-i-1381 lexical-ls-1382)
+                             (if (< lexical-i-1381 '0)
+                                 lexical-ls-1382
+                                 (lexical-do-1380
+                                  (- lexical-i-1381 '1)
+                                  (cons (lexical-fn-1378
+                                         (vector-ref
+                                          lexical-v-1379
+                                          lexical-i-1381))
+                                        lexical-ls-1382))))))
+                   lexical-do-1380)
+                 (- (vector-length lexical-v-1379) '1)
+                 '())))
+             (lexical-vfor-each-515
+              (lambda (lexical-fn-1383 lexical-v-1384)
+                ((lambda (lexical-len-1385)
+                   ((letrec ((lexical-do-1386
+                              (lambda (lexical-i-1387)
+                                (if (not (= lexical-i-1387 lexical-len-1385))
+                                    (begin
+                                      (lexical-fn-1383
+                                       (vector-ref
+                                        lexical-v-1384
+                                        lexical-i-1387))
+                                      (lexical-do-1386 (+ lexical-i-1387 '1)))
+                                    (void)))))
+                      lexical-do-1386)
+                    '0))
+                 (vector-length lexical-v-1384))))
+             (lexical-do-top-import-516
+              (lambda (lexical-import-only?-1388
+                       lexical-top-ribcage-1389
+                       lexical-mid-1390
+                       lexical-token-1391)
+                (list '$sc-put-cte
+                      (list 'quote lexical-mid-1390)
+                      (list 'quote (cons 'do-import lexical-token-1391))
+                      (list 'quote
+                            (lexical-top-ribcage-key-402
+                             lexical-top-ribcage-1389)))))
+             (lexical-update-mode-set-517
+              ((lambda (lexical-table-1392)
+                 (lambda (lexical-when-list-1393 lexical-mode-set-1394)
+                   (letrec* ((lexical-remq-1395
+                              (lambda (lexical-x-1396 lexical-ls-1397)
+                                (if (null? lexical-ls-1397)
+                                    '()
+                                    (if (eq? (car lexical-ls-1397)
+                                             lexical-x-1396)
+                                        (lexical-remq-1395
+                                         lexical-x-1396
+                                         (cdr lexical-ls-1397))
+                                        (cons (car lexical-ls-1397)
+                                              (lexical-remq-1395
+                                               lexical-x-1396
+                                               (cdr lexical-ls-1397))))))))
+                     (lexical-remq-1395
+                      '-
+                      (apply append
+                             (map (lambda (lexical-m-1398)
+                                    ((lambda (lexical-row-1399)
+                                       (map (lambda (lexical-s-1400)
+                                              (cdr (assq lexical-s-1400
+                                                         lexical-row-1399)))
+                                            lexical-when-list-1393))
+                                     (cdr (assq lexical-m-1398
+                                                lexical-table-1392))))
+                                  lexical-mode-set-1394))))))
+               '((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)))))
+             (lexical-initial-mode-set-518
+              (lambda (lexical-when-list-1401 lexical-compiling-a-file-1402)
+                (apply append
+                       (map (lambda (lexical-s-1403)
+                              (if lexical-compiling-a-file-1402
+                                  ((lambda (lexical-t-1404)
+                                     (if (memv lexical-t-1404 '(compile))
+                                         '(C)
+                                         (if (memv lexical-t-1404 '(load))
+                                             '(L)
+                                             (if (memv lexical-t-1404 '(visit))
+                                                 '(V)
+                                                 (if (memv lexical-t-1404
+                                                           '(revisit))
+                                                     '(R)
+                                                     '())))))
+                                   lexical-s-1403)
+                                  ((lambda (lexical-t-1405)
+                                     (if (memv lexical-t-1405 '(eval))
+                                         '(E)
+                                         '()))
+                                   lexical-s-1403)))
+                            lexical-when-list-1401))))
+             (lexical-rt-eval/residualize-519
+              (lambda (lexical-rtem-1406 lexical-thunk-1407)
+                (if (memq 'E lexical-rtem-1406)
+                    (lexical-thunk-1407)
+                    ((lambda (lexical-thunk-1408)
+                       (if (memq 'V lexical-rtem-1406)
+                           (if ((lambda (lexical-t-1409)
+                                  (if lexical-t-1409
+                                      lexical-t-1409
+                                      (memq 'R lexical-rtem-1406)))
+                                (memq 'L lexical-rtem-1406))
+                               (lexical-thunk-1408)
+                               (lexical-thunk-1408))
+                           (if ((lambda (lexical-t-1410)
+                                  (if lexical-t-1410
+                                      lexical-t-1410
+                                      (memq 'R lexical-rtem-1406)))
+                                (memq 'L lexical-rtem-1406))
+                               (lexical-thunk-1408)
+                               (lexical-chi-void-546))))
+                     (if (memq 'C lexical-rtem-1406)
+                         ((lambda (lexical-x-1411)
+                            (begin
+                              (lexical-top-level-eval-hook-159 lexical-x-1411)
+                              (lambda () lexical-x-1411)))
+                          (lexical-thunk-1407))
+                         lexical-thunk-1407)))))
+             (lexical-ct-eval/residualize2-520
+              (lambda (lexical-ctem-1412 lexical-thunk-1413)
+                ((lambda (lexical-t-1414)
+                   (lexical-ct-eval/residualize3-521
+                    lexical-ctem-1412
+                    (lambda ()
+                      (begin
+                        (if (not lexical-t-1414)
+                            (set! lexical-t-1414 (lexical-thunk-1413))
+                            (void))
+                        (lexical-top-level-eval-hook-159 lexical-t-1414)))
+                    (lambda ()
+                      ((lambda (lexical-t-1415)
+                         (if lexical-t-1415
+                             lexical-t-1415
+                             (lexical-thunk-1413)))
+                       lexical-t-1414))))
+                 '#f)))
+             (lexical-ct-eval/residualize3-521
+              (lambda (lexical-ctem-1416
+                       lexical-eval-thunk-1417
+                       lexical-residualize-thunk-1418)
+                (if (memq 'E lexical-ctem-1416)
+                    (begin (lexical-eval-thunk-1417) (lexical-chi-void-546))
+                    (begin
+                      (if (memq 'C lexical-ctem-1416)
+                          (lexical-eval-thunk-1417)
+                          (void))
+                      (if (memq 'R lexical-ctem-1416)
+                          (if ((lambda (lexical-t-1419)
+                                 (if lexical-t-1419
+                                     lexical-t-1419
+                                     (memq 'V lexical-ctem-1416)))
+                               (memq 'L lexical-ctem-1416))
+                              (lexical-residualize-thunk-1418)
+                              (lexical-residualize-thunk-1418))
+                          (if ((lambda (lexical-t-1420)
+                                 (if lexical-t-1420
+                                     lexical-t-1420
+                                     (memq 'V lexical-ctem-1416)))
+                               (memq 'L lexical-ctem-1416))
+                              (lexical-residualize-thunk-1418)
+                              (lexical-chi-void-546)))))))
+             (lexical-chi-frobs-522
+              (lambda (lexical-frob*-1421
+                       lexical-r-1422
+                       lexical-mr-1423
+                       lexical-m?-1424)
+                (map (lambda (lexical-x-1425)
+                       (lexical-chi-525
+                        (lexical-frob-e-505 lexical-x-1425)
+                        lexical-r-1422
+                        lexical-mr-1423
+                        '(())
+                        lexical-m?-1424))
+                     lexical-frob*-1421)))
+             (lexical-chi-meta-frob-523
+              (lambda (lexical-x-1426 lexical-mr-1427)
+                (lexical-chi-525
+                 (lexical-frob-e-505 lexical-x-1426)
+                 lexical-mr-1427
+                 lexical-mr-1427
+                 '(())
+                 '#t)))
+             (lexical-chi-sequence-524
+              (lambda (lexical-body-1428
+                       lexical-r-1429
+                       lexical-mr-1430
+                       lexical-w-1431
+                       lexical-ae-1432
+                       lexical-m?-1433)
+                (lexical-build-sequence-261
+                 lexical-ae-1432
+                 ((letrec ((lexical-dobody-1434
+                            (lambda (lexical-body-1435)
+                              (if (null? lexical-body-1435)
+                                  '()
+                                  ((lambda (lexical-first-1436)
+                                     (cons lexical-first-1436
+                                           (lexical-dobody-1434
+                                            (cdr lexical-body-1435))))
+                                   (lexical-chi-525
+                                    (car lexical-body-1435)
+                                    lexical-r-1429
+                                    lexical-mr-1430
+                                    lexical-w-1431
+                                    lexical-m?-1433))))))
+                    lexical-dobody-1434)
+                  lexical-body-1428))))
+             (lexical-chi-525
+              (lambda (lexical-e-1437
+                       lexical-r-1438
+                       lexical-mr-1439
+                       lexical-w-1440
+                       lexical-m?-1441)
+                (call-with-values
+                 (lambda ()
+                   (lexical-syntax-type-473
+                    lexical-e-1437
+                    lexical-r-1438
+                    lexical-w-1440
+                    '#f
+                    '#f))
+                 (lambda (lexical-type-1442
+                          lexical-value-1443
+                          lexical-e-1444
+                          lexical-w-1445
+                          lexical-ae-1446)
+                   (lexical-chi-expr-526
+                    lexical-type-1442
+                    lexical-value-1443
+                    lexical-e-1444
+                    lexical-r-1438
+                    lexical-mr-1439
+                    lexical-w-1445
+                    lexical-ae-1446
+                    lexical-m?-1441)))))
+             (lexical-chi-expr-526
+              (lambda (lexical-type-1447
+                       lexical-value-1448
+                       lexical-e-1449
+                       lexical-r-1450
+                       lexical-mr-1451
+                       lexical-w-1452
+                       lexical-ae-1453
+                       lexical-m?-1454)
+                ((lambda (lexical-t-1455)
+                   (if (memv lexical-t-1455 '(lexical))
+                       lexical-value-1448
+                       (if (memv lexical-t-1455 '(core))
+                           (lexical-value-1448
+                            lexical-e-1449
+                            lexical-r-1450
+                            lexical-mr-1451
+                            lexical-w-1452
+                            lexical-ae-1453
+                            lexical-m?-1454)
+                           (if (memv lexical-t-1455 '(lexical-call))
+                               (lexical-chi-application-527
+                                lexical-value-1448
+                                lexical-e-1449
+                                lexical-r-1450
+                                lexical-mr-1451
+                                lexical-w-1452
+                                lexical-ae-1453
+                                lexical-m?-1454)
+                               (if (memv lexical-t-1455 '(constant))
+                                   (list 'quote
+                                         (lexical-strip-550
+                                          (lexical-source-wrap-471
+                                           lexical-e-1449
+                                           lexical-w-1452
+                                           lexical-ae-1453)
+                                          '(())))
+                                   (if (memv lexical-t-1455 '(global))
+                                       lexical-value-1448
+                                       (if (memv lexical-t-1455
+                                                 '(meta-variable))
+                                           (if lexical-m?-1454
+                                               lexical-value-1448
+                                               (lexical-displaced-lexical-error-326
+                                                (lexical-source-wrap-471
+                                                 lexical-e-1449
+                                                 lexical-w-1452
+                                                 lexical-ae-1453)))
+                                           (if (memv lexical-t-1455 '(call))
+                                               (lexical-chi-application-527
+                                                (lexical-chi-525
+                                                 (car lexical-e-1449)
+                                                 lexical-r-1450
+                                                 lexical-mr-1451
+                                                 lexical-w-1452
+                                                 lexical-m?-1454)
+                                                lexical-e-1449
+                                                lexical-r-1450
+                                                lexical-mr-1451
+                                                lexical-w-1452
+                                                lexical-ae-1453
+                                                lexical-m?-1454)
+                                               (if (memv lexical-t-1455
+                                                         '(begin-form))
+                                                   (lexical-chi-sequence-524
+                                                    (lexical-parse-begin-543
+                                                     lexical-e-1449
+                                                     lexical-w-1452
+                                                     lexical-ae-1453
+                                                     '#f)
+                                                    lexical-r-1450
+                                                    lexical-mr-1451
+                                                    lexical-w-1452
+                                                    lexical-ae-1453
+                                                    lexical-m?-1454)
+                                                   (if (memv lexical-t-1455
+                                                             '(local-syntax-form))
+                                                       (call-with-values
+                                                        (lambda ()
+                                                          (lexical-chi-local-syntax-545
+                                                           lexical-value-1448
+                                                           lexical-e-1449
+                                                           lexical-r-1450
+                                                           lexical-mr-1451
+                                                           lexical-w-1452
+                                                           lexical-ae-1453))
+                                                        (lambda (lexical-forms-1456
+                                                                 lexical-r-1457
+                                                                 lexical-mr-1458
+                                                                 lexical-w-1459
+                                                                 lexical-ae-1460)
+                                                          (lexical-chi-sequence-524
+                                                           lexical-forms-1456
+                                                           lexical-r-1457
+                                                           lexical-mr-1458
+                                                           lexical-w-1459
+                                                           lexical-ae-1460
+                                                           lexical-m?-1454)))
+                                                       (if (memv lexical-t-1455
+                                                                 '(eval-when-form))
+                                                           (call-with-values
+                                                            (lambda ()
+                                                              (lexical-parse-eval-when-541
+                                                               lexical-e-1449
+                                                               lexical-w-1452
+                                                               lexical-ae-1453))
+                                                            (lambda (lexical-when-list-1461
+                                                                     lexical-forms-1462)
+                                                              (if (memq 'eval
+                                                                        lexical-when-list-1461)
+                                                                  (lexical-chi-sequence-524
+                                                                   lexical-forms-1462
+                                                                   lexical-r-1450
+                                                                   lexical-mr-1451
+                                                                   lexical-w-1452
+                                                                   lexical-ae-1453
+                                                                   lexical-m?-1454)
+                                                                  (lexical-chi-void-546))))
+                                                           (if (memv lexical-t-1455
+                                                                     '(meta-form))
+                                                               (syntax-error
+                                                                (lexical-source-wrap-471
+                                                                 lexical-e-1449
+                                                                 lexical-w-1452
+                                                                 lexical-ae-1453)
+                                                                '"invalid context for meta definition")
+                                                               (if (memv lexical-t-1455
+                                                                         '(define-form))
+                                                                   (begin
+                                                                     (lexical-parse-define-538
+                                                                      lexical-e-1449
+                                                                      lexical-w-1452
+                                                                      lexical-ae-1453)
+                                                                     (syntax-error
+                                                                      (lexical-source-wrap-471
+                                                                       lexical-e-1449
+                                                                       lexical-w-1452
+                                                                       lexical-ae-1453)
+                                                                      '"invalid context for definition"))
+                                                                   (if (memv lexical-t-1455
+                                                                             '(define-syntax-form))
+                                                                       (begin
+                                                                         (lexical-parse-define-syntax-539
+                                                                          lexical-e-1449
+                                                                          lexical-w-1452
+                                                                          lexical-ae-1453)
+                                                                         (syntax-error
+                                                                          (lexical-source-wrap-471
+                                                                           lexical-e-1449
+                                                                           lexical-w-1452
+                                                                           lexical-ae-1453)
+                                                                          '"invalid context for definition"))
+                                                                       (if (memv lexical-t-1455
+                                                                                 '($module-form))
+                                                                           (call-with-values
+                                                                            (lambda ()
+                                                                              (lexical-parse-module-536
+                                                                               lexical-e-1449
+                                                                               lexical-w-1452
+                                                                               lexical-ae-1453
+                                                                               lexical-w-1452))
+                                                                            (lambda (lexical-orig-1463
+                                                                                     lexical-id-1464
+                                                                                     lexical-exports-1465
+                                                                                     lexical-forms-1466)
+                                                                              (syntax-error
+                                                                               lexical-orig-1463
+                                                                               '"invalid context for definition")))
+                                                                           (if (memv lexical-t-1455
+                                                                                     '($import-form))
+                                                                               (call-with-values
+                                                                                (lambda ()
+                                                                                  (lexical-parse-import-537
+                                                                                   lexical-e-1449
+                                                                                   lexical-w-1452
+                                                                                   lexical-ae-1453))
+                                                                                (lambda (lexical-orig-1467
+                                                                                         lexical-only?-1468
+                                                                                         lexical-mid-1469)
+                                                                                  (syntax-error
+                                                                                   lexical-orig-1467
+                                                                                   '"invalid context for definition")))
+                                                                               (if (memv lexical-t-1455
+                                                                                         '(alias-form))
+                                                                                   (begin
+                                                                                     (lexical-parse-alias-542
+                                                                                      lexical-e-1449
+                                                                                      lexical-w-1452
+                                                                                      lexical-ae-1453)
+                                                                                     (syntax-error
+                                                                                      (lexical-source-wrap-471
+                                                                                       lexical-e-1449
+                                                                                       lexical-w-1452
+                                                                                       lexical-ae-1453)
+                                                                                      '"invalid context for definition"))
+                                                                                   (if (memv lexical-t-1455
+                                                                                             '(syntax))
+                                                                                       (syntax-error
+                                                                                        (lexical-source-wrap-471
+                                                                                         lexical-e-1449
+                                                                                         lexical-w-1452
+                                                                                         lexical-ae-1453)
+                                                                                        '"reference to pattern variable outside syntax form")
+                                                                                       (if (memv lexical-t-1455
+                                                                                                 '(displaced-lexical))
+                                                                                           (lexical-displaced-lexical-error-326
+                                                                                            (lexical-source-wrap-471
+                                                                                             lexical-e-1449
+                                                                                             lexical-w-1452
+                                                                                             lexical-ae-1453))
+                                                                                           (syntax-error
+                                                                                            (lexical-source-wrap-471
+                                                                                             lexical-e-1449
+                                                                                             lexical-w-1452
+                                                                                             lexical-ae-1453)))))))))))))))))))))
+                 lexical-type-1447)))
+             (lexical-chi-application-527
+              (lambda (lexical-x-1470
+                       lexical-e-1471
+                       lexical-r-1472
+                       lexical-mr-1473
+                       lexical-w-1474
+                       lexical-ae-1475
+                       lexical-m?-1476)
+                ((lambda (lexical-tmp-1477)
+                   ((lambda (lexical-tmp-1478)
+                      (if lexical-tmp-1478
+                          (apply (lambda (lexical-e0-1479 lexical-e1-1480)
+                                   (cons lexical-x-1470
+                                         (map (lambda (lexical-e-1481)
+                                                (lexical-chi-525
+                                                 lexical-e-1481
+                                                 lexical-r-1472
+                                                 lexical-mr-1473
+                                                 lexical-w-1474
+                                                 lexical-m?-1476))
+                                              lexical-e1-1480)))
+                                 lexical-tmp-1478)
+                          ((lambda (lexical-_-1483)
+                             (syntax-error
+                              (lexical-source-wrap-471
+                               lexical-e-1471
+                               lexical-w-1474
+                               lexical-ae-1475)))
+                           lexical-tmp-1477)))
+                    ($syntax-dispatch lexical-tmp-1477 '(any . each-any))))
+                 lexical-e-1471)))
+             (lexical-chi-set!-528
+              (lambda (lexical-e-1484
+                       lexical-r-1485
+                       lexical-w-1486
+                       lexical-ae-1487
+                       lexical-rib-1488)
+                ((lambda (lexical-tmp-1489)
+                   ((lambda (lexical-tmp-1490)
+                      (if (if lexical-tmp-1490
+                              (apply (lambda (lexical-_-1491
+                                              lexical-id-1492
+                                              lexical-val-1493)
+                                       (lexical-id?-333 lexical-id-1492))
+                                     lexical-tmp-1490)
+                              '#f)
+                          (apply (lambda (lexical-_-1494
+                                          lexical-id-1495
+                                          lexical-val-1496)
+                                   ((lambda (lexical-n-1497)
+                                      ((lambda (lexical-b-1498)
+                                         ((lambda (lexical-t-1499)
+                                            (if (memv lexical-t-1499 '(macro!))
+                                                ((lambda (lexical-id-1500
+                                                          lexical-val-1501)
+                                                   (lexical-syntax-type-473
+                                                    (lexical-chi-macro-529
+                                                     (lexical-binding-value-309
+                                                      lexical-b-1498)
+                                                     (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
+                                                                  call-or-value
+                                                                  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?
+                                                                  tmp-wrap
+                                                                  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-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
+                                                                  update-import-binding!
+                                                                  get-import-binding
+                                                                  read-only-binding?
+                                                                  put-global-definition-hook
+                                                                  get-global-definition-hook
+                                                                  put-cte-hook
+                                                                  error-hook
+                                                                  define-top-level-value-hook
+                                                                  local-eval-hook
+                                                                  top-level-eval-hook
+                                                                  annotation?
+                                                                  fx>=
+                                                                  fx<=
+                                                                  fx>
+                                                                  fx<
+                                                                  fx=
+                                                                  fx-
+                                                                  fx+
+                                                                  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)
+                                                                  (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)
+                                                                  (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"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"))
+                                                               #(top-ribcage
+                                                                 *top*
+                                                                 #t)))
+                                                           lexical-id-1500
+                                                           lexical-val-1501)
+                                                     lexical-r-1485
+                                                     '(())
+                                                     '#f
+                                                     lexical-rib-1488)
+                                                    lexical-r-1485
+                                                    '(())
+                                                    '#f
+                                                    lexical-rib-1488))
+                                                 (lexical-wrap-470
+                                                  lexical-id-1495
+                                                  lexical-w-1486)
+                                                 (lexical-wrap-470
+                                                  lexical-val-1496
+                                                  lexical-w-1486))
+                                                (values
+                                                 'core
+                                                 (lambda (lexical-e-1502
+                                                          lexical-r-1503
+                                                          lexical-mr-1504
+                                                          lexical-w-1505
+                                                          lexical-ae-1506
+                                                          lexical-m?-1507)
+                                                   ((lambda (lexical-val-1508
+                                                             lexical-n-1509)
+                                                      ((lambda (lexical-b-1510)
+                                                         ((lambda (lexical-t-1511)
+                                                            (if (memv lexical-t-1511
+                                                                      '(lexical))
+                                                                (list 'set!
+                                                                      (lexical-binding-value-309
+                                                                       lexical-b-1510)
+                                                                      lexical-val-1508)
+                                                                (if (memv lexical-t-1511
+                                                                          '(global))
+                                                                    ((lambda (lexical-sym-1512)
+                                                                       (begin
+                                                                         (if (lexical-read-only-binding?-166
+                                                                              lexical-n-1509)
+                                                                             (syntax-error
+                                                                              (lexical-source-wrap-471
+                                                                               lexical-e-1502
+                                                                               lexical-w-1505
+                                                                               lexical-ae-1506)
+                                                                              '"invalid assignment to read-only variable")
+                                                                             (void))
+                                                                         (list 'set!
+                                                                               lexical-sym-1512
+                                                                               lexical-val-1508)))
+                                                                     (lexical-binding-value-309
+                                                                      lexical-b-1510))
+                                                                    (if (memv lexical-t-1511
+                                                                              '(meta-variable))
+                                                                        (if lexical-m?-1507
+                                                                            (list 'set!
+                                                                                  (lexical-binding-value-309
+                                                                                   lexical-b-1510)
+                                                                                  lexical-val-1508)
+                                                                            (lexical-displaced-lexical-error-326
+                                                                             (lexical-wrap-470
+                                                                              lexical-id-1495
+                                                                              lexical-w-1505)))
+                                                                        (if (memv lexical-t-1511
+                                                                                  '(displaced-lexical))
+                                                                            (lexical-displaced-lexical-error-326
+                                                                             (lexical-wrap-470
+                                                                              lexical-id-1495
+                                                                              lexical-w-1505))
+                                                                            (syntax-error
+                                                                             (lexical-source-wrap-471
+                                                                              lexical-e-1502
+                                                                              lexical-w-1505
+                                                                              lexical-ae-1506)))))))
+                                                          (lexical-binding-type-308
+                                                           lexical-b-1510)))
+                                                       (lexical-lookup-328
+                                                        lexical-n-1509
+                                                        lexical-r-1503)))
+                                                    (lexical-chi-525
+                                                     lexical-val-1496
+                                                     lexical-r-1503
+                                                     lexical-mr-1504
+                                                     lexical-w-1505
+                                                     lexical-m?-1507)
+                                                    (lexical-id-var-name-461
+                                                     lexical-id-1495
+                                                     lexical-w-1505)))
+                                                 lexical-e-1484
+                                                 lexical-w-1486
+                                                 lexical-ae-1487)))
+                                          (lexical-binding-type-308
+                                           lexical-b-1498)))
+                                       (lexical-lookup-328
+                                        lexical-n-1497
+                                        lexical-r-1485)))
+                                    (lexical-id-var-name-461
+                                     lexical-id-1495
+                                     lexical-w-1486)))
+                                 lexical-tmp-1490)
+                          ((lambda (lexical-_-1513)
+                             (syntax-error
+                              (lexical-source-wrap-471
+                               lexical-e-1484
+                               lexical-w-1486
+                               lexical-ae-1487)))
+                           lexical-tmp-1489)))
+                    ($syntax-dispatch lexical-tmp-1489 '(any any any))))
+                 lexical-e-1484)))
+             (lexical-chi-macro-529
+              (lambda (lexical-p-1514
+                       lexical-e-1515
+                       lexical-r-1516
+                       lexical-w-1517
+                       lexical-ae-1518
+                       lexical-rib-1519)
+                (letrec* ((lexical-rebuild-macro-output-1520
+                           (lambda (lexical-x-1521 lexical-m-1522)
+                             (if (pair? lexical-x-1521)
+                                 (cons (lexical-rebuild-macro-output-1520
+                                        (car lexical-x-1521)
+                                        lexical-m-1522)
+                                       (lexical-rebuild-macro-output-1520
+                                        (cdr lexical-x-1521)
+                                        lexical-m-1522))
+                                 (if (lexical-syntax-object?-90 lexical-x-1521)
+                                     ((lambda (lexical-w-1523)
+                                        ((lambda (lexical-ms-1524
+                                                  lexical-s-1525)
+                                           (lexical-make-syntax-object-89
+                                            (lexical-syntax-object-expression-91
+                                             lexical-x-1521)
+                                            (if (if (pair? lexical-ms-1524)
+                                                    (eq? (car lexical-ms-1524)
+                                                         '#f)
+                                                    '#f)
+                                                (lexical-make-wrap-342
+                                                 (cdr lexical-ms-1524)
+                                                 (cdr lexical-s-1525))
+                                                (lexical-make-wrap-342
+                                                 (cons lexical-m-1522
+                                                       lexical-ms-1524)
+                                                 (if lexical-rib-1519
+                                                     (cons lexical-rib-1519
+                                                           (cons 'shift
+                                                                 lexical-s-1525))
+                                                     (cons 'shift
+                                                           lexical-s-1525))))))
+                                         (lexical-wrap-marks-343
+                                          lexical-w-1523)
+                                         (lexical-wrap-subst-344
+                                          lexical-w-1523)))
+                                      (lexical-syntax-object-wrap-92
+                                       lexical-x-1521))
+                                     (if (vector? lexical-x-1521)
+                                         ((lambda (lexical-n-1526)
+                                            ((lambda (lexical-v-1527)
+                                               ((lambda ()
+                                                  ((letrec ((lexical-do-1528
+                                                             (lambda (lexical-i-1529)
+                                                               (if (= lexical-i-1529
+                                                                      lexical-n-1526)
+                                                                   lexical-v-1527
+                                                                   (begin
+                                                                     (vector-set!
+                                                                      lexical-v-1527
+                                                                      lexical-i-1529
+                                                                      (lexical-rebuild-macro-output-1520
+                                                                       (vector-ref
+                                                                        lexical-x-1521
+                                                                        lexical-i-1529)
+                                                                       lexical-m-1522))
+                                                                     (lexical-do-1528
+                                                                      (+ lexical-i-1529
+                                                                         '1)))))))
+                                                     lexical-do-1528)
+                                                   '0))))
+                                             (make-vector lexical-n-1526)))
+                                          (vector-length lexical-x-1521))
+                                         (if (symbol? lexical-x-1521)
+                                             (syntax-error
+                                              (lexical-source-wrap-471
+                                               lexical-e-1515
+                                               lexical-w-1517
+                                               lexical-ae-1518)
+                                              '"encountered raw symbol "
+                                              (symbol->string lexical-x-1521)
+                                              '" in output of macro")
+                                             lexical-x-1521)))))))
+                  (lexical-rebuild-macro-output-1520
+                   (lexical-call-or-value-530
+                    (lexical-p-1514
+                     (lexical-source-wrap-471
+                      lexical-e-1515
+                      (lexical-anti-mark-427 lexical-w-1517)
+                      lexical-ae-1518))
+                    (lambda (lexical-id-1530)
+                      (begin
+                        (if (not (identifier? lexical-id-1530))
+                            (syntax-error
+                             lexical-id-1530
+                             '"environment argument is not an identifier")
+                            (void))
+                        (lexical-lookup-328
+                         (lexical-id-var-name-461 lexical-id-1530 '(()))
+                         lexical-r-1516))))
+                   (string '#\m)))))
+             (lexical-call-or-value-530
+              (lambda (lexical-p/v-1531 lexical-arg-1532)
+                (if (procedure? lexical-p/v-1531)
+                    (lexical-p/v-1531 lexical-arg-1532)
+                    lexical-p/v-1531)))
+             (lexical-chi-body-531
+              (lambda (lexical-body-1533
+                       lexical-outer-form-1534
+                       lexical-r-1535
+                       lexical-mr-1536
+                       lexical-w-1537
+                       lexical-m?-1538)
+                ((lambda (lexical-ribcage-1539)
+                   ((lambda (lexical-w-1540)
+                      ((lambda (lexical-body-1541)
+                         ((lambda ()
+                            (call-with-values
+                             (lambda ()
+                               (lexical-chi-internal-532
+                                lexical-ribcage-1539
+                                lexical-outer-form-1534
+                                lexical-body-1541
+                                lexical-r-1535
+                                lexical-mr-1536
+                                lexical-m?-1538))
+                             (lambda (lexical-r-1542
+                                      lexical-mr-1543
+                                      lexical-exprs-1544
+                                      lexical-ids-1545
+                                      lexical-vars-1546
+                                      lexical-vals-1547
+                                      lexical-inits-1548)
+                               (begin
+                                 (if (null? lexical-exprs-1544)
+                                     (syntax-error
+                                      lexical-outer-form-1534
+                                      '"no expressions in body")
+                                     (void))
+                                 (lexical-build-body-264
+                                  '#f
+                                  (reverse lexical-vars-1546)
+                                  (lexical-chi-frobs-522
+                                   (reverse lexical-vals-1547)
+                                   lexical-r-1542
+                                   lexical-mr-1543
+                                   lexical-m?-1538)
+                                  (lexical-build-sequence-261
+                                   '#f
+                                   (lexical-chi-frobs-522
+                                    (append
+                                     lexical-inits-1548
+                                     lexical-exprs-1544)
+                                    lexical-r-1542
+                                    lexical-mr-1543
+                                    lexical-m?-1538)))))))))
+                       (map (lambda (lexical-x-1549)
+                              (lexical-make-frob-503
+                               (lexical-wrap-470 lexical-x-1549 lexical-w-1540)
+                               '#f))
+                            lexical-body-1533)))
+                    (lexical-make-wrap-342
+                     (lexical-wrap-marks-343 lexical-w-1537)
+                     (cons lexical-ribcage-1539
+                           (lexical-wrap-subst-344 lexical-w-1537)))))
+                 (lexical-make-ribcage-392 '() '() '()))))
+             (lexical-chi-internal-532
+              (lambda (lexical-ribcage-1550
+                       lexical-source-exp-1551
+                       lexical-body-1552
+                       lexical-r-1553
+                       lexical-mr-1554
+                       lexical-m?-1555)
+                (letrec* ((lexical-return-1556
+                           (lambda (lexical-r-1557
+                                    lexical-mr-1558
+                                    lexical-exprs-1559
+                                    lexical-ids-1560
+                                    lexical-vars-1561
+                                    lexical-vals-1562
+                                    lexical-inits-1563)
+                             (begin
+                               (lexical-check-defined-ids-512
+                                lexical-source-exp-1551
+                                lexical-ids-1560)
+                               (values
+                                lexical-r-1557
+                                lexical-mr-1558
+                                lexical-exprs-1559
+                                lexical-ids-1560
+                                lexical-vars-1561
+                                lexical-vals-1562
+                                lexical-inits-1563)))))
+                  ((letrec ((lexical-parse-1564
+                             (lambda (lexical-body-1565
+                                      lexical-r-1566
+                                      lexical-mr-1567
+                                      lexical-ids-1568
+                                      lexical-vars-1569
+                                      lexical-vals-1570
+                                      lexical-inits-1571
+                                      lexical-meta-seen?-1572)
+                               (if (null? lexical-body-1565)
+                                   (lexical-return-1556
+                                    lexical-r-1566
+                                    lexical-mr-1567
+                                    lexical-body-1565
+                                    lexical-ids-1568
+                                    lexical-vars-1569
+                                    lexical-vals-1570
+                                    lexical-inits-1571)
+                                   ((lambda (lexical-fr-1573)
+                                      ((lambda (lexical-e-1574)
+                                         ((lambda (lexical-meta?-1575)
+                                            ((lambda ()
+                                               (call-with-values
+                                                (lambda ()
+                                                  (lexical-syntax-type-473
+                                                   lexical-e-1574
+                                                   lexical-r-1566
+                                                   '(())
+                                                   '#f
+                                                   lexical-ribcage-1550))
+                                                (lambda (lexical-type-1576
+                                                         lexical-value-1577
+                                                         lexical-e-1578
+                                                         lexical-w-1579
+                                                         lexical-ae-1580)
+                                                  ((lambda (lexical-t-1581)
+                                                     (if (memv lexical-t-1581
+                                                               '(define-form))
+                                                         (call-with-values
+                                                          (lambda ()
+                                                            (lexical-parse-define-538
+                                                             lexical-e-1578
+                                                             lexical-w-1579
+                                                             lexical-ae-1580))
+                                                          (lambda (lexical-id-1582
+                                                                   lexical-rhs-1583
+                                                                   lexical-w-1584)
+                                                            ((lambda (lexical-id-1585
+                                                                      lexical-label-1586)
+                                                               (if lexical-meta?-1575
+                                                                   ((lambda (lexical-sym-1587)
+                                                                      (begin
+                                                                        (lexical-extend-ribcage!-437
+                                                                         lexical-ribcage-1550
+                                                                         lexical-id-1585
+                                                                         lexical-label-1586)
+                                                                        ((lambda (lexical-mr-1588)
+                                                                           (begin
+                                                                             (lexical-define-top-level-value-hook-161
+                                                                              lexical-sym-1587
+                                                                              (lexical-top-level-eval-hook-159
+                                                                               (lexical-chi-525
+                                                                                lexical-rhs-1583
+                                                                                lexical-mr-1588
+                                                                                lexical-mr-1588
+                                                                                lexical-w-1584
+                                                                                '#t)))
+                                                                             (lexical-parse-1564
+                                                                              (cdr lexical-body-1565)
+                                                                              lexical-r-1566
+                                                                              lexical-mr-1588
+                                                                              (cons lexical-id-1585
+                                                                                    lexical-ids-1568)
+                                                                              lexical-vars-1569
+                                                                              lexical-vals-1570
+                                                                              lexical-inits-1571
+                                                                              '#f)))
+                                                                         (lexical-extend-env-322
+                                                                          lexical-label-1586
+                                                                          (cons 'meta-variable
+                                                                                lexical-sym-1587)
+                                                                          lexical-mr-1567))))
+                                                                    (lexical-generate-id-169
+                                                                     ((lambda (lexical-x-1589)
+                                                                        ((lambda (lexical-e-1590)
+                                                                           (if (lexical-annotation?-158
+                                                                                lexical-e-1590)
+                                                                               (annotation-expression
+                                                                                lexical-e-1590)
+                                                                               lexical-e-1590))
+                                                                         (if (lexical-syntax-object?-90
+                                                                              lexical-x-1589)
+                                                                             (lexical-syntax-object-expression-91
+                                                                              lexical-x-1589)
+                                                                             lexical-x-1589)))
+                                                                      lexical-id-1585)))
+                                                                   ((lambda (lexical-var-1591)
+                                                                      (begin
+                                                                        (lexical-extend-ribcage!-437
+                                                                         lexical-ribcage-1550
+                                                                         lexical-id-1585
+                                                                         lexical-label-1586)
+                                                                        (lexical-parse-1564
+                                                                         (cdr lexical-body-1565)
+                                                                         (lexical-extend-env-322
+                                                                          lexical-label-1586
+                                                                          (cons 'lexical
+                                                                                lexical-var-1591)
+                                                                          lexical-r-1566)
+                                                                         lexical-mr-1567
+                                                                         (cons lexical-id-1585
+                                                                               lexical-ids-1568)
+                                                                         (cons lexical-var-1591
+                                                                               lexical-vars-1569)
+                                                                         (cons (lexical-make-frob-503
+                                                                                (lexical-wrap-470
+                                                                                 lexical-rhs-1583
+                                                                                 lexical-w-1584)
+                                                                                lexical-meta?-1575)
+                                                                               lexical-vals-1570)
+                                                                         lexical-inits-1571
+                                                                         '#f)))
+                                                                    (lexical-gen-var-551
+                                                                     lexical-id-1585))))
+                                                             (lexical-wrap-470
+                                                              lexical-id-1582
+                                                              lexical-w-1584)
+                                                             (lexical-gen-label-389))))
+                                                         (if (memv lexical-t-1581
+                                                                   '(define-syntax-form))
+                                                             (call-with-values
+                                                              (lambda ()
+                                                                (lexical-parse-define-syntax-539
+                                                                 lexical-e-1578
+                                                                 lexical-w-1579
+                                                                 lexical-ae-1580))
+                                                              (lambda (lexical-id-1592
+                                                                       lexical-rhs-1593
+                                                                       lexical-w-1594)
+                                                                ((lambda (lexical-id-1595
+                                                                          lexical-label-1596
+                                                                          lexical-exp-1597)
+                                                                   (begin
+                                                                     (lexical-extend-ribcage!-437
+                                                                      lexical-ribcage-1550
+                                                                      lexical-id-1595
+                                                                      lexical-label-1596)
+                                                                     ((lambda (lexical-b-1598)
+                                                                        (lexical-parse-1564
+                                                                         (cdr lexical-body-1565)
+                                                                         (lexical-extend-env-322
+                                                                          lexical-label-1596
+                                                                          lexical-b-1598
+                                                                          lexical-r-1566)
+                                                                         (lexical-extend-env-322
+                                                                          lexical-label-1596
+                                                                          lexical-b-1598
+                                                                          lexical-mr-1567)
+                                                                         (cons lexical-id-1595
+                                                                               lexical-ids-1568)
+                                                                         lexical-vars-1569
+                                                                         lexical-vals-1570
+                                                                         lexical-inits-1571
+                                                                         '#f))
+                                                                      (lexical-defer-or-eval-transformer-330
+                                                                       lexical-local-eval-hook-160
+                                                                       lexical-exp-1597))))
+                                                                 (lexical-wrap-470
+                                                                  lexical-id-1592
+                                                                  lexical-w-1594)
+                                                                 (lexical-gen-label-389)
+                                                                 (lexical-chi-525
+                                                                  lexical-rhs-1593
+                                                                  lexical-mr-1567
+                                                                  lexical-mr-1567
+                                                                  lexical-w-1594
+                                                                  '#t))))
+                                                             (if (memv lexical-t-1581
+                                                                       '($module-form))
+                                                                 ((lambda (lexical-*ribcage-1599)
+                                                                    ((lambda (lexical-*w-1600)
+                                                                       ((lambda ()
+                                                                          (call-with-values
+                                                                           (lambda ()
+                                                                             (lexical-parse-module-536
+                                                                              lexical-e-1578
+                                                                              lexical-w-1579
+                                                                              lexical-ae-1580
+                                                                              lexical-*w-1600))
+                                                                           (lambda (lexical-orig-1601
+                                                                                    lexical-id-1602
+                                                                                    lexical-exports-1603
+                                                                                    lexical-forms-1604)
+                                                                             (call-with-values
+                                                                              (lambda ()
+                                                                                (lexical-chi-internal-532
+                                                                                 lexical-*ribcage-1599
+                                                                                 lexical-orig-1601
+                                                                                 (map (lambda (lexical-d-1605)
+                                                                                        (lexical-make-frob-503
+                                                                                         lexical-d-1605
+                                                                                         lexical-meta?-1575))
+                                                                                      lexical-forms-1604)
+                                                                                 lexical-r-1566
+                                                                                 lexical-mr-1567
+                                                                                 lexical-m?-1555))
+                                                                              (lambda (lexical-r-1606
+                                                                                       lexical-mr-1607
+                                                                                       lexical-*body-1608
+                                                                                       lexical-*ids-1609
+                                                                                       lexical-*vars-1610
+                                                                                       lexical-*vals-1611
+                                                                                       lexical-*inits-1612)
+                                                                                (begin
+                                                                                  (lexical-check-module-exports-511
+                                                                                   lexical-source-exp-1551
+                                                                                   (lexical-flatten-exports-477
+                                                                                    lexical-exports-1603)
+                                                                                   lexical-*ids-1609)
+                                                                                  ((lambda (lexical-iface-1613
+                                                                                            lexical-vars-1614
+                                                                                            lexical-vals-1615
+                                                                                            lexical-inits-1616
+                                                                                            lexical-label-1617)
+                                                                                     (begin
+                                                                                       (lexical-extend-ribcage!-437
+                                                                                        lexical-ribcage-1550
+                                                                                        lexical-id-1602
+                                                                                        lexical-label-1617)
+                                                                                       ((lambda (lexical-b-1618)
+                                                                                          (lexical-parse-1564
+                                                                                           (cdr lexical-body-1565)
+                                                                                           (lexical-extend-env-322
+                                                                                            lexical-label-1617
+                                                                                            lexical-b-1618
+                                                                                            lexical-r-1606)
+                                                                                           (lexical-extend-env-322
+                                                                                            lexical-label-1617
+                                                                                            lexical-b-1618
+                                                                                            lexical-mr-1607)
+                                                                                           (cons lexical-id-1602
+                                                                                                 lexical-ids-1568)
+                                                                                           lexical-vars-1614
+                                                                                           lexical-vals-1615
+                                                                                           lexical-inits-1616
+                                                                                           '#f))
+                                                                                        (cons '$module
+                                                                                              lexical-iface-1613))))
+                                                                                   (lexical-make-resolved-interface-487
+                                                                                    lexical-id-1602
+                                                                                    lexical-exports-1603
+                                                                                    '#f)
+                                                                                   (append
+                                                                                    lexical-*vars-1610
+                                                                                    lexical-vars-1569)
+                                                                                   (append
+                                                                                    lexical-*vals-1611
+                                                                                    lexical-vals-1570)
+                                                                                   (append
+                                                                                    lexical-inits-1571
+                                                                                    lexical-*inits-1612
+                                                                                    lexical-*body-1608)
+                                                                                   (lexical-gen-label-389))))))))))
+                                                                     (lexical-make-wrap-342
+                                                                      (lexical-wrap-marks-343
+                                                                       lexical-w-1579)
+                                                                      (cons lexical-*ribcage-1599
+                                                                            (lexical-wrap-subst-344
+                                                                             lexical-w-1579)))))
+                                                                  (lexical-make-ribcage-392
+                                                                   '()
+                                                                   '()
+                                                                   '()))
+                                                                 (if (memv lexical-t-1581
+                                                                           '($import-form))
+                                                                     (call-with-values
+                                                                      (lambda ()
+                                                                        (lexical-parse-import-537
+                                                                         lexical-e-1578
+                                                                         lexical-w-1579
+                                                                         lexical-ae-1580))
+                                                                      (lambda (lexical-orig-1619
+                                                                               lexical-only?-1620
+                                                                               lexical-mid-1621)
+                                                                        ((lambda (lexical-mlabel-1622)
+                                                                           ((lambda (lexical-binding-1623)
+                                                                              ((lambda (lexical-t-1624)
+                                                                                 (if (memv lexical-t-1624
+                                                                                           '($module))
+                                                                                     ((lambda (lexical-iface-1625)
+                                                                                        ((lambda (lexical-import-iface-1626)
+                                                                                           ((lambda ()
+                                                                                              (begin
+                                                                                                (if lexical-only?-1620
+                                                                                                    (lexical-extend-ribcage-barrier!-439
+                                                                                                     lexical-ribcage-1550
+                                                                                                     lexical-mid-1621)
+                                                                                                    (void))
+                                                                                                (lexical-do-import!-535
+                                                                                                 lexical-import-iface-1626
+                                                                                                 lexical-ribcage-1550)
+                                                                                                (lexical-parse-1564
+                                                                                                 (cdr lexical-body-1565)
+                                                                                                 lexical-r-1566
+                                                                                                 lexical-mr-1567
+                                                                                                 (cons lexical-import-iface-1626
+                                                                                                       lexical-ids-1568)
+                                                                                                 lexical-vars-1569
+                                                                                                 lexical-vals-1570
+                                                                                                 lexical-inits-1571
+                                                                                                 '#f)))))
+                                                                                         (lexical-make-import-interface-406
+                                                                                          lexical-iface-1625
+                                                                                          (lexical-import-mark-delta-533
+                                                                                           lexical-mid-1621
+                                                                                           lexical-iface-1625))))
+                                                                                      (lexical-binding-value-309
+                                                                                       lexical-binding-1623))
+                                                                                     (if (memv lexical-t-1624
+                                                                                               '(displaced-lexical))
+                                                                                         (lexical-displaced-lexical-error-326
+                                                                                          lexical-mid-1621)
+                                                                                         (syntax-error
+                                                                                          lexical-mid-1621
+                                                                                          '"unknown module"))))
+                                                                               (lexical-binding-type-308
+                                                                                lexical-binding-1623)))
+                                                                            (lexical-lookup-328
+                                                                             lexical-mlabel-1622
+                                                                             lexical-r-1566)))
+                                                                         (lexical-id-var-name-461
+                                                                          lexical-mid-1621
+                                                                          '(())))))
+                                                                     (if (memv lexical-t-1581
+                                                                               '(alias-form))
+                                                                         (call-with-values
+                                                                          (lambda ()
+                                                                            (lexical-parse-alias-542
+                                                                             lexical-e-1578
+                                                                             lexical-w-1579
+                                                                             lexical-ae-1580))
+                                                                          (lambda (lexical-new-id-1627
+                                                                                   lexical-old-id-1628)
+                                                                            ((lambda (lexical-new-id-1629)
+                                                                               (begin
+                                                                                 (lexical-extend-ribcage!-437
+                                                                                  lexical-ribcage-1550
+                                                                                  lexical-new-id-1629
+                                                                                  (lexical-id-var-name-loc-460
+                                                                                   lexical-old-id-1628
+                                                                                   lexical-w-1579))
+                                                                                 (lexical-parse-1564
+                                                                                  (cdr lexical-body-1565)
+                                                                                  lexical-r-1566
+                                                                                  lexical-mr-1567
+                                                                                  (cons lexical-new-id-1629
+                                                                                        lexical-ids-1568)
+                                                                                  lexical-vars-1569
+                                                                                  lexical-vals-1570
+                                                                                  lexical-inits-1571
+                                                                                  '#f)))
+                                                                             (lexical-wrap-470
+                                                                              lexical-new-id-1627
+                                                                              lexical-w-1579))))
+                                                                         (if (memv lexical-t-1581
+                                                                                   '(begin-form))
+                                                                             (lexical-parse-1564
+                                                                              ((letrec ((lexical-f-1630
+                                                                                         (lambda (lexical-forms-1631)
+                                                                                           (if (null? lexical-forms-1631)
+                                                                                               (cdr lexical-body-1565)
+                                                                                               (cons (lexical-make-frob-503
+                                                                                                      (lexical-wrap-470
+                                                                                                       (car lexical-forms-1631)
+                                                                                                       lexical-w-1579)
+                                                                                                      lexical-meta?-1575)
+                                                                                                     (lexical-f-1630
+                                                                                                      (cdr lexical-forms-1631)))))))
+                                                                                 lexical-f-1630)
+                                                                               (lexical-parse-begin-543
+                                                                                lexical-e-1578
+                                                                                lexical-w-1579
+                                                                                lexical-ae-1580
+                                                                                '#t))
+                                                                              lexical-r-1566
+                                                                              lexical-mr-1567
+                                                                              lexical-ids-1568
+                                                                              lexical-vars-1569
+                                                                              lexical-vals-1570
+                                                                              lexical-inits-1571
+                                                                              '#f)
+                                                                             (if (memv lexical-t-1581
+                                                                                       '(eval-when-form))
+                                                                                 (call-with-values
+                                                                                  (lambda ()
+                                                                                    (lexical-parse-eval-when-541
+                                                                                     lexical-e-1578
+                                                                                     lexical-w-1579
+                                                                                     lexical-ae-1580))
+                                                                                  (lambda (lexical-when-list-1632
+                                                                                           lexical-forms-1633)
+                                                                                    (lexical-parse-1564
+                                                                                     (if (memq 'eval
+                                                                                               lexical-when-list-1632)
+                                                                                         ((letrec ((lexical-f-1634
+                                                                                                    (lambda (lexical-forms-1635)
+                                                                                                      (if (null? lexical-forms-1635)
+                                                                                                          (cdr lexical-body-1565)
+                                                                                                          (cons (lexical-make-frob-503
+                                                                                                                 (lexical-wrap-470
+                                                                                                                  (car lexical-forms-1635)
+                                                                                                                  lexical-w-1579)
+                                                                                                                 lexical-meta?-1575)
+                                                                                                                (lexical-f-1634
+                                                                                                                 (cdr lexical-forms-1635)))))))
+                                                                                            lexical-f-1634)
+                                                                                          lexical-forms-1633)
+                                                                                         (cdr lexical-body-1565))
+                                                                                     lexical-r-1566
+                                                                                     lexical-mr-1567
+                                                                                     lexical-ids-1568
+                                                                                     lexical-vars-1569
+                                                                                     lexical-vals-1570
+                                                                                     lexical-inits-1571
+                                                                                     '#f)))
+                                                                                 (if (memv lexical-t-1581
+                                                                                           '(meta-form))
+                                                                                     (lexical-parse-1564
+                                                                                      (cons (lexical-make-frob-503
+                                                                                             (lexical-wrap-470
+                                                                                              (lexical-parse-meta-540
+                                                                                               lexical-e-1578
+                                                                                               lexical-w-1579
+                                                                                               lexical-ae-1580)
+                                                                                              lexical-w-1579)
+                                                                                             '#t)
+                                                                                            (cdr lexical-body-1565))
+                                                                                      lexical-r-1566
+                                                                                      lexical-mr-1567
+                                                                                      lexical-ids-1568
+                                                                                      lexical-vars-1569
+                                                                                      lexical-vals-1570
+                                                                                      lexical-inits-1571
+                                                                                      '#t)
+                                                                                     (if (memv lexical-t-1581
+                                                                                               '(local-syntax-form))
+                                                                                         (call-with-values
+                                                                                          (lambda ()
+                                                                                            (lexical-chi-local-syntax-545
+                                                                                             lexical-value-1577
+                                                                                             lexical-e-1578
+                                                                                             lexical-r-1566
+                                                                                             lexical-mr-1567
+                                                                                             lexical-w-1579
+                                                                                             lexical-ae-1580))
+                                                                                          (lambda (lexical-forms-1636
+                                                                                                   lexical-r-1637
+                                                                                                   lexical-mr-1638
+                                                                                                   lexical-w-1639
+                                                                                                   lexical-ae-1640)
+                                                                                            (lexical-parse-1564
+                                                                                             ((letrec ((lexical-f-1641
+                                                                                                        (lambda (lexical-forms-1642)
+                                                                                                          (if (null? lexical-forms-1642)
+                                                                                                              (cdr lexical-body-1565)
+                                                                                                              (cons (lexical-make-frob-503
+                                                                                                                     (lexical-wrap-470
+                                                                                                                      (car lexical-forms-1642)
+                                                                                                                      lexical-w-1639)
+                                                                                                                     lexical-meta?-1575)
+                                                                                                                    (lexical-f-1641
+                                                                                                                     (cdr lexical-forms-1642)))))))
+                                                                                                lexical-f-1641)
+                                                                                              lexical-forms-1636)
+                                                                                             lexical-r-1637
+                                                                                             lexical-mr-1638
+                                                                                             lexical-ids-1568
+                                                                                             lexical-vars-1569
+                                                                                             lexical-vals-1570
+                                                                                             lexical-inits-1571
+                                                                                             '#f)))
+                                                                                         (begin
+                                                                                           (if lexical-meta-seen?-1572
+                                                                                               (syntax-error
+                                                                                                (lexical-source-wrap-471
+                                                                                                 lexical-e-1578
+                                                                                                 lexical-w-1579
+                                                                                                 lexical-ae-1580)
+                                                                                                '"invalid meta definition")
+                                                                                               (void))
+                                                                                           ((letrec ((lexical-f-1643
+                                                                                                      (lambda (lexical-body-1644)
+                                                                                                        (if ((lambda (lexical-t-1645)
+                                                                                                               (if lexical-t-1645
+                                                                                                                   lexical-t-1645
+                                                                                                                   (not (lexical-frob-meta?-506
+                                                                                                                         (car lexical-body-1644)))))
+                                                                                                             (null? lexical-body-1644))
+                                                                                                            (lexical-return-1556
+                                                                                                             lexical-r-1566
+                                                                                                             lexical-mr-1567
+                                                                                                             lexical-body-1644
+                                                                                                             lexical-ids-1568
+                                                                                                             lexical-vars-1569
+                                                                                                             lexical-vals-1570
+                                                                                                             lexical-inits-1571)
+                                                                                                            (begin
+                                                                                                              (lexical-top-level-eval-hook-159
+                                                                                                               (lexical-chi-meta-frob-523
+                                                                                                                (car lexical-body-1644)
+                                                                                                                lexical-mr-1567))
+                                                                                                              (lexical-f-1643
+                                                                                                               (cdr lexical-body-1644)))))))
+                                                                                              lexical-f-1643)
+                                                                                            (cons (lexical-make-frob-503
+                                                                                                   (lexical-source-wrap-471
+                                                                                                    lexical-e-1578
+                                                                                                    lexical-w-1579
+                                                                                                    lexical-ae-1580)
+                                                                                                   lexical-meta?-1575)
+                                                                                                  (cdr lexical-body-1565))))))))))))))
+                                                   lexical-type-1576))))))
+                                          (lexical-frob-meta?-506
+                                           lexical-fr-1573)))
+                                       (lexical-frob-e-505 lexical-fr-1573)))
+                                    (car lexical-body-1565))))))
+                     lexical-parse-1564)
+                   lexical-body-1552
+                   lexical-r-1553
+                   lexical-mr-1554
+                   '()
+                   '()
+                   '()
+                   '()
+                   '#f))))
+             (lexical-import-mark-delta-533
+              (lambda (lexical-mid-1646 lexical-iface-1647)
+                (lexical-diff-marks-453
+                 (lexical-id-marks-339 lexical-mid-1646)
+                 (lexical-interface-marks-480 lexical-iface-1647))))
+             (lexical-lookup-import-label-534
+              (lambda (lexical-id-1648)
+                ((lambda (lexical-label-1649)
+                   (begin
+                     (if (not lexical-label-1649)
+                         (syntax-error
+                          lexical-id-1648
+                          '"exported identifier not visible")
+                         (void))
+                     lexical-label-1649))
+                 (lexical-id-var-name-loc-460 lexical-id-1648 '(())))))
+             (lexical-do-import!-535
+              (lambda (lexical-import-iface-1650 lexical-ribcage-1651)
+                ((lambda (lexical-ie-1652)
+                   (if (<= (vector-length lexical-ie-1652) '20)
+                       ((lambda (lexical-new-marks-1653)
+                          (lexical-vfor-each-515
+                           (lambda (lexical-id-1654)
+                             (lexical-import-extend-ribcage!-438
+                              lexical-ribcage-1651
+                              lexical-new-marks-1653
+                              lexical-id-1654
+                              (lexical-lookup-import-label-534 lexical-id-1654)))
+                           lexical-ie-1652))
+                        (lexical-import-interface-new-marks-409
+                         lexical-import-iface-1650))
+                       (lexical-extend-ribcage-subst!-441
+                        lexical-ribcage-1651
+                        lexical-import-iface-1650)))
+                 (lexical-interface-exports-481
+                  (lexical-import-interface-interface-408
+                   lexical-import-iface-1650)))))
+             (lexical-parse-module-536
+              (lambda (lexical-e-1655
+                       lexical-w-1656
+                       lexical-ae-1657
+                       lexical-*w-1658)
+                (letrec* ((lexical-listify-1659
+                           (lambda (lexical-exports-1660)
+                             (if (null? lexical-exports-1660)
+                                 '()
+                                 (cons ((lambda (lexical-tmp-1661)
+                                          ((lambda (lexical-tmp-1662)
+                                             (if lexical-tmp-1662
+                                                 (apply (lambda (lexical-ex-1663)
+                                                          (lexical-listify-1659
+                                                           lexical-ex-1663))
+                                                        lexical-tmp-1662)
+                                                 ((lambda (lexical-x-1665)
+                                                    (if (lexical-id?-333
+                                                         lexical-x-1665)
+                                                        (lexical-wrap-470
+                                                         lexical-x-1665
+                                                         lexical-*w-1658)
+                                                        (syntax-error
+                                                         (lexical-source-wrap-471
+                                                          lexical-e-1655
+                                                          lexical-w-1656
+                                                          lexical-ae-1657)
+                                                         '"invalid exports list in")))
+                                                  lexical-tmp-1661)))
+                                           ($syntax-dispatch
+                                            lexical-tmp-1661
+                                            'each-any)))
+                                        (car lexical-exports-1660))
+                                       (lexical-listify-1659
+                                        (cdr lexical-exports-1660)))))))
+                  ((lambda (lexical-tmp-1666)
+                     ((lambda (lexical-tmp-1667)
+                        (if (if lexical-tmp-1667
+                                (apply (lambda (lexical-_-1668
+                                                lexical-orig-1669
+                                                lexical-mid-1670
+                                                lexical-ex-1671
+                                                lexical-form-1672)
+                                         (lexical-id?-333 lexical-mid-1670))
+                                       lexical-tmp-1667)
+                                '#f)
+                            (apply (lambda (lexical-_-1673
+                                            lexical-orig-1674
+                                            lexical-mid-1675
+                                            lexical-ex-1676
+                                            lexical-form-1677)
+                                     (values
+                                      lexical-orig-1674
+                                      (lexical-wrap-470
+                                       lexical-mid-1675
+                                       lexical-w-1656)
+                                      (lexical-listify-1659 lexical-ex-1676)
+                                      (map (lambda (lexical-x-1679)
+                                             (lexical-wrap-470
+                                              lexical-x-1679
+                                              lexical-*w-1658))
+                                           lexical-form-1677)))
+                                   lexical-tmp-1667)
+                            ((lambda (lexical-_-1681)
+                               (syntax-error
+                                (lexical-source-wrap-471
+                                 lexical-e-1655
+                                 lexical-w-1656
+                                 lexical-ae-1657)))
+                             lexical-tmp-1666)))
+                      ($syntax-dispatch
+                       lexical-tmp-1666
+                       '(any any any each-any . each-any))))
+                   lexical-e-1655))))
+             (lexical-parse-import-537
+              (lambda (lexical-e-1682 lexical-w-1683 lexical-ae-1684)
+                ((lambda (lexical-tmp-1685)
+                   ((lambda (lexical-tmp-1686)
+                      (if (if lexical-tmp-1686
+                              (apply (lambda (lexical-_-1687
+                                              lexical-orig-1688
+                                              lexical-mid-1689)
+                                       (lexical-id?-333 lexical-mid-1689))
+                                     lexical-tmp-1686)
+                              '#f)
+                          (apply (lambda (lexical-_-1690
+                                          lexical-orig-1691
+                                          lexical-mid-1692)
+                                   (values
+                                    lexical-orig-1691
+                                    '#t
+                                    (lexical-wrap-470
+                                     lexical-mid-1692
+                                     lexical-w-1683)))
+                                 lexical-tmp-1686)
+                          ((lambda (lexical-tmp-1693)
+                             (if (if lexical-tmp-1693
+                                     (apply (lambda (lexical-_-1694
+                                                     lexical-orig-1695
+                                                     lexical-mid-1696)
+                                              (lexical-id?-333
+                                               lexical-mid-1696))
+                                            lexical-tmp-1693)
+                                     '#f)
+                                 (apply (lambda (lexical-_-1697
+                                                 lexical-orig-1698
+                                                 lexical-mid-1699)
+                                          (values
+                                           lexical-orig-1698
+                                           '#f
+                                           (lexical-wrap-470
+                                            lexical-mid-1699
+                                            lexical-w-1683)))
+                                        lexical-tmp-1693)
+                                 ((lambda (lexical-_-1700)
+                                    (syntax-error
+                                     (lexical-source-wrap-471
+                                      lexical-e-1682
+                                      lexical-w-1683
+                                      lexical-ae-1684)))
+                                  lexical-tmp-1685)))
+                           ($syntax-dispatch
+                            lexical-tmp-1685
+                            '(any any #(atom #f) any)))))
+                    ($syntax-dispatch
+                     lexical-tmp-1685
+                     '(any any #(atom #t) any))))
+                 lexical-e-1682)))
+             (lexical-parse-define-538
+              (lambda (lexical-e-1701 lexical-w-1702 lexical-ae-1703)
+                ((lambda (lexical-tmp-1704)
+                   ((lambda (lexical-tmp-1705)
+                      (if (if lexical-tmp-1705
+                              (apply (lambda (lexical-_-1706
+                                              lexical-name-1707
+                                              lexical-val-1708)
+                                       (lexical-id?-333 lexical-name-1707))
+                                     lexical-tmp-1705)
+                              '#f)
+                          (apply (lambda (lexical-_-1709
+                                          lexical-name-1710
+                                          lexical-val-1711)
+                                   (values
+                                    lexical-name-1710
+                                    lexical-val-1711
+                                    lexical-w-1702))
+                                 lexical-tmp-1705)
+                          ((lambda (lexical-tmp-1712)
+                             (if (if lexical-tmp-1712
+                                     (apply (lambda (lexical-_-1713
+                                                     lexical-name-1714
+                                                     lexical-args-1715
+                                                     lexical-e1-1716
+                                                     lexical-e2-1717)
+                                              (if (lexical-id?-333
+                                                   lexical-name-1714)
+                                                  (lexical-valid-bound-ids?-466
+                                                   (lexical-lambda-var-list-552
+                                                    lexical-args-1715))
+                                                  '#f))
+                                            lexical-tmp-1712)
+                                     '#f)
+                                 (apply (lambda (lexical-_-1718
+                                                 lexical-name-1719
+                                                 lexical-args-1720
+                                                 lexical-e1-1721
+                                                 lexical-e2-1722)
+                                          (values
+                                           (lexical-wrap-470
+                                            lexical-name-1719
+                                            lexical-w-1702)
+                                           (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
+                                                        call-or-value
+                                                        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?
+                                                        tmp-wrap
+                                                        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-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
+                                                        update-import-binding!
+                                                        get-import-binding
+                                                        read-only-binding?
+                                                        put-global-definition-hook
+                                                        get-global-definition-hook
+                                                        put-cte-hook
+                                                        error-hook
+                                                        define-top-level-value-hook
+                                                        local-eval-hook
+                                                        top-level-eval-hook
+                                                        annotation?
+                                                        fx>=
+                                                        fx<=
+                                                        fx>
+                                                        fx<
+                                                        fx=
+                                                        fx-
+                                                        fx+
+                                                        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)
+                                                        (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)
+                                                        (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"
+                                                        "i"
+                                                        "i"
+                                                        "i"
+                                                        "i"
+                                                        "i"
+                                                        "i"
+                                                        "i"
+                                                        "i"
+                                                        "i"))
+                                                     #(top-ribcage *top* #t)))
+                                                 (lexical-wrap-470
+                                                  (cons lexical-args-1720
+                                                        (cons lexical-e1-1721
+                                                              lexical-e2-1722))
+                                                  lexical-w-1702))
+                                           '(())))
+                                        lexical-tmp-1712)
+                                 ((lambda (lexical-tmp-1724)
+                                    (if (if lexical-tmp-1724
+                                            (apply (lambda (lexical-_-1725
+                                                            lexical-name-1726)
+                                                     (lexical-id?-333
+                                                      lexical-name-1726))
+                                                   lexical-tmp-1724)
+                                            '#f)
+                                        (apply (lambda (lexical-_-1727
+                                                        lexical-name-1728)
+                                                 (values
+                                                  (lexical-wrap-470
+                                                   lexical-name-1728
+                                                   lexical-w-1702)
+                                                  '#(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
+                                                         call-or-value
+                                                         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?
+                                                         tmp-wrap
+                                                         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-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
+                                                         update-import-binding!
+                                                         get-import-binding
+                                                         read-only-binding?
+                                                         put-global-definition-hook
+                                                         get-global-definition-hook
+                                                         put-cte-hook
+                                                         error-hook
+                                                         define-top-level-value-hook
+                                                         local-eval-hook
+                                                         top-level-eval-hook
+                                                         annotation?
+                                                         fx>=
+                                                         fx<=
+                                                         fx>
+                                                         fx<
+                                                         fx=
+                                                         fx-
+                                                         fx+
+                                                         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)
+                                                         (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)
+                                                         (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"
+                                                         "i"
+                                                         "i"
+                                                         "i"
+                                                         "i"
+                                                         "i"
+                                                         "i"
+                                                         "i"
+                                                         "i"
+                                                         "i"))
+                                                      #(top-ribcage *top* #t)))
+                                                  '(())))
+                                               lexical-tmp-1724)
+                                        ((lambda (lexical-_-1729)
+                                           (syntax-error
+                                            (lexical-source-wrap-471
+                                             lexical-e-1701
+                                             lexical-w-1702
+                                             lexical-ae-1703)))
+                                         lexical-tmp-1704)))
+                                  ($syntax-dispatch
+                                   lexical-tmp-1704
+                                   '(any any)))))
+                           ($syntax-dispatch
+                            lexical-tmp-1704
+                            '(any (any . any) any . each-any)))))
+                    ($syntax-dispatch lexical-tmp-1704 '(any any any))))
+                 lexical-e-1701)))
+             (lexical-parse-define-syntax-539
+              (lambda (lexical-e-1730 lexical-w-1731 lexical-ae-1732)
+                ((lambda (lexical-tmp-1733)
+                   ((lambda (lexical-tmp-1734)
+                      (if (if lexical-tmp-1734
+                              (apply (lambda (lexical-_-1735
+                                              lexical-name-1736
+                                              lexical-id-1737
+                                              lexical-e1-1738
+                                              lexical-e2-1739)
+                                       (if (lexical-id?-333 lexical-name-1736)
+                                           (lexical-id?-333 lexical-id-1737)
+                                           '#f))
+                                     lexical-tmp-1734)
+                              '#f)
+                          (apply (lambda (lexical-_-1740
+                                          lexical-name-1741
+                                          lexical-id-1742
+                                          lexical-e1-1743
+                                          lexical-e2-1744)
+                                   (values
+                                    (lexical-wrap-470
+                                     lexical-name-1741
+                                     lexical-w-1731)
+                                    (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
+                                                 call-or-value
+                                                 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?
+                                                 tmp-wrap
+                                                 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-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
+                                                 update-import-binding!
+                                                 get-import-binding
+                                                 read-only-binding?
+                                                 put-global-definition-hook
+                                                 get-global-definition-hook
+                                                 put-cte-hook
+                                                 error-hook
+                                                 define-top-level-value-hook
+                                                 local-eval-hook
+                                                 top-level-eval-hook
+                                                 annotation?
+                                                 fx>=
+                                                 fx<=
+                                                 fx>
+                                                 fx<
+                                                 fx=
+                                                 fx-
+                                                 fx+
+                                                 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)
+                                                 (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)
+                                                 (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"
+                                                 "i"
+                                                 "i"
+                                                 "i"
+                                                 "i"
+                                                 "i"
+                                                 "i"
+                                                 "i"
+                                                 "i"
+                                                 "i"))
+                                              #(top-ribcage *top* #t)))
+                                          (cons (lexical-wrap-470
+                                                 (list lexical-id-1742)
+                                                 lexical-w-1731)
+                                                (lexical-wrap-470
+                                                 (cons lexical-e1-1743
+                                                       lexical-e2-1744)
+                                                 lexical-w-1731)))
+                                    '(())))
+                                 lexical-tmp-1734)
+                          ((lambda (lexical-tmp-1746)
+                             (if (if lexical-tmp-1746
+                                     (apply (lambda (lexical-_-1747
+                                                     lexical-name-1748
+                                                     lexical-val-1749)
+                                              (lexical-id?-333
+                                               lexical-name-1748))
+                                            lexical-tmp-1746)
+                                     '#f)
+                                 (apply (lambda (lexical-_-1750
+                                                 lexical-name-1751
+                                                 lexical-val-1752)
+                                          (values
+                                           lexical-name-1751
+                                           lexical-val-1752
+                                           lexical-w-1731))
+                                        lexical-tmp-1746)
+                                 ((lambda (lexical-_-1753)
+                                    (syntax-error
+                                     (lexical-source-wrap-471
+                                      lexical-e-1730
+                                      lexical-w-1731
+                                      lexical-ae-1732)))
+                                  lexical-tmp-1733)))
+                           ($syntax-dispatch lexical-tmp-1733 '(any any any)))))
+                    ($syntax-dispatch
+                     lexical-tmp-1733
+                     '(any (any any) any . each-any))))
+                 lexical-e-1730)))
+             (lexical-parse-meta-540
+              (lambda (lexical-e-1754 lexical-w-1755 lexical-ae-1756)
+                ((lambda (lexical-tmp-1757)
+                   ((lambda (lexical-tmp-1758)
+                      (if lexical-tmp-1758
+                          (apply (lambda (lexical-_-1759 lexical-form-1760)
+                                   lexical-form-1760)
+                                 lexical-tmp-1758)
+                          ((lambda (lexical-_-1761)
+                             (syntax-error
+                              (lexical-source-wrap-471
+                               lexical-e-1754
+                               lexical-w-1755
+                               lexical-ae-1756)))
+                           lexical-tmp-1757)))
+                    ($syntax-dispatch lexical-tmp-1757 '(any . any))))
+                 lexical-e-1754)))
+             (lexical-parse-eval-when-541
+              (lambda (lexical-e-1762 lexical-w-1763 lexical-ae-1764)
+                ((lambda (lexical-tmp-1765)
+                   ((lambda (lexical-tmp-1766)
+                      (if lexical-tmp-1766
+                          (apply (lambda (lexical-_-1767
+                                          lexical-x-1768
+                                          lexical-e1-1769
+                                          lexical-e2-1770)
+                                   (values
+                                    (lexical-chi-when-list-472
+                                     lexical-x-1768
+                                     lexical-w-1763)
+                                    (cons lexical-e1-1769 lexical-e2-1770)))
+                                 lexical-tmp-1766)
+                          ((lambda (lexical-_-1773)
+                             (syntax-error
+                              (lexical-source-wrap-471
+                               lexical-e-1762
+                               lexical-w-1763
+                               lexical-ae-1764)))
+                           lexical-tmp-1765)))
+                    ($syntax-dispatch
+                     lexical-tmp-1765
+                     '(any each-any any . each-any))))
+                 lexical-e-1762)))
+             (lexical-parse-alias-542
+              (lambda (lexical-e-1774 lexical-w-1775 lexical-ae-1776)
+                ((lambda (lexical-tmp-1777)
+                   ((lambda (lexical-tmp-1778)
+                      (if (if lexical-tmp-1778
+                              (apply (lambda (lexical-_-1779
+                                              lexical-new-id-1780
+                                              lexical-old-id-1781)
+                                       (if (lexical-id?-333
+                                            lexical-new-id-1780)
+                                           (lexical-id?-333
+                                            lexical-old-id-1781)
+                                           '#f))
+                                     lexical-tmp-1778)
+                              '#f)
+                          (apply (lambda (lexical-_-1782
+                                          lexical-new-id-1783
+                                          lexical-old-id-1784)
+                                   (values
+                                    lexical-new-id-1783
+                                    lexical-old-id-1784))
+                                 lexical-tmp-1778)
+                          ((lambda (lexical-_-1785)
+                             (syntax-error
+                              (lexical-source-wrap-471
+                               lexical-e-1774
+                               lexical-w-1775
+                               lexical-ae-1776)))
+                           lexical-tmp-1777)))
+                    ($syntax-dispatch lexical-tmp-1777 '(any any any))))
+                 lexical-e-1774)))
+             (lexical-parse-begin-543
+              (lambda (lexical-e-1786
+                       lexical-w-1787
+                       lexical-ae-1788
+                       lexical-empty-okay?-1789)
+                ((lambda (lexical-tmp-1790)
+                   ((lambda (lexical-tmp-1791)
+                      (if (if lexical-tmp-1791
+                              (apply (lambda (lexical-_-1792)
+                                       lexical-empty-okay?-1789)
+                                     lexical-tmp-1791)
+                              '#f)
+                          (apply (lambda (lexical-_-1793) '())
+                                 lexical-tmp-1791)
+                          ((lambda (lexical-tmp-1794)
+                             (if lexical-tmp-1794
+                                 (apply (lambda (lexical-_-1795
+                                                 lexical-e1-1796
+                                                 lexical-e2-1797)
+                                          (cons lexical-e1-1796
+                                                lexical-e2-1797))
+                                        lexical-tmp-1794)
+                                 ((lambda (lexical-_-1799)
+                                    (syntax-error
+                                     (lexical-source-wrap-471
+                                      lexical-e-1786
+                                      lexical-w-1787
+                                      lexical-ae-1788)))
+                                  lexical-tmp-1790)))
+                           ($syntax-dispatch
+                            lexical-tmp-1790
+                            '(any any . each-any)))))
+                    ($syntax-dispatch lexical-tmp-1790 '(any))))
+                 lexical-e-1786)))
+             (lexical-chi-lambda-clause-544
+              (lambda (lexical-e-1800
+                       lexical-c-1801
+                       lexical-r-1802
+                       lexical-mr-1803
+                       lexical-w-1804
+                       lexical-m?-1805)
+                ((lambda (lexical-tmp-1806)
+                   ((lambda (lexical-tmp-1807)
+                      (if lexical-tmp-1807
+                          (apply (lambda (lexical-id-1808
+                                          lexical-e1-1809
+                                          lexical-e2-1810)
+                                   ((lambda (lexical-ids-1811)
+                                      (if (not (lexical-valid-bound-ids?-466
+                                                lexical-ids-1811))
+                                          (syntax-error
+                                           lexical-e-1800
+                                           '"invalid parameter list in")
+                                          ((lambda (lexical-labels-1812
+                                                    lexical-new-vars-1813)
+                                             (values
+                                              lexical-new-vars-1813
+                                              (lexical-chi-body-531
+                                               (cons lexical-e1-1809
+                                                     lexical-e2-1810)
+                                               lexical-e-1800
+                                               (lexical-extend-var-env*-324
+                                                lexical-labels-1812
+                                                lexical-new-vars-1813
+                                                lexical-r-1802)
+                                               lexical-mr-1803
+                                               (lexical-make-binding-wrap-444
+                                                lexical-ids-1811
+                                                lexical-labels-1812
+                                                lexical-w-1804)
+                                               lexical-m?-1805)))
+                                           (lexical-gen-labels-391
+                                            lexical-ids-1811)
+                                           (map lexical-gen-var-551
+                                                lexical-ids-1811))))
+                                    lexical-id-1808))
+                                 lexical-tmp-1807)
+                          ((lambda (lexical-tmp-1816)
+                             (if lexical-tmp-1816
+                                 (apply (lambda (lexical-ids-1817
+                                                 lexical-e1-1818
+                                                 lexical-e2-1819)
+                                          ((lambda (lexical-old-ids-1820)
+                                             (if (not (lexical-valid-bound-ids?-466
+                                                       lexical-old-ids-1820))
+                                                 (syntax-error
+                                                  lexical-e-1800
+                                                  '"invalid parameter list in")
+                                                 ((lambda (lexical-labels-1821
+                                                           lexical-new-vars-1822)
+                                                    (values
+                                                     ((letrec ((lexical-f-1823
+                                                                (lambda (lexical-ls1-1824
+                                                                         lexical-ls2-1825)
+                                                                  (if (null? lexical-ls1-1824)
+                                                                      lexical-ls2-1825
+                                                                      (lexical-f-1823
+                                                                       (cdr lexical-ls1-1824)
+                                                                       (cons (car lexical-ls1-1824)
+                                                                             lexical-ls2-1825))))))
+                                                        lexical-f-1823)
+                                                      (cdr lexical-new-vars-1822)
+                                                      (car lexical-new-vars-1822))
+                                                     (lexical-chi-body-531
+                                                      (cons lexical-e1-1818
+                                                            lexical-e2-1819)
+                                                      lexical-e-1800
+                                                      (lexical-extend-var-env*-324
+                                                       lexical-labels-1821
+                                                       lexical-new-vars-1822
+                                                       lexical-r-1802)
+                                                      lexical-mr-1803
+                                                      (lexical-make-binding-wrap-444
+                                                       lexical-old-ids-1820
+                                                       lexical-labels-1821
+                                                       lexical-w-1804)
+                                                      lexical-m?-1805)))
+                                                  (lexical-gen-labels-391
+                                                   lexical-old-ids-1820)
+                                                  (map lexical-gen-var-551
+                                                       lexical-old-ids-1820))))
+                                           (lexical-lambda-var-list-552
+                                            lexical-ids-1817)))
+                                        lexical-tmp-1816)
+                                 ((lambda (lexical-_-1827)
+                                    (syntax-error lexical-e-1800))
+                                  lexical-tmp-1806)))
+                           ($syntax-dispatch
+                            lexical-tmp-1806
+                            '(any any . each-any)))))
+                    ($syntax-dispatch
+                     lexical-tmp-1806
+                     '(each-any any . each-any))))
+                 lexical-c-1801)))
+             (lexical-chi-local-syntax-545
+              (lambda (lexical-rec?-1828
+                       lexical-e-1829
+                       lexical-r-1830
+                       lexical-mr-1831
+                       lexical-w-1832
+                       lexical-ae-1833)
+                ((lambda (lexical-tmp-1834)
+                   ((lambda (lexical-tmp-1835)
+                      (if lexical-tmp-1835
+                          (apply (lambda (lexical-_-1836
+                                          lexical-id-1837
+                                          lexical-val-1838
+                                          lexical-e1-1839
+                                          lexical-e2-1840)
+                                   ((lambda (lexical-ids-1841)
+                                      (if (not (lexical-valid-bound-ids?-466
+                                                lexical-ids-1841))
+                                          (lexical-invalid-ids-error-468
+                                           (map (lambda (lexical-x-1842)
+                                                  (lexical-wrap-470
+                                                   lexical-x-1842
+                                                   lexical-w-1832))
+                                                lexical-ids-1841)
+                                           (lexical-source-wrap-471
+                                            lexical-e-1829
+                                            lexical-w-1832
+                                            lexical-ae-1833)
+                                           '"keyword")
+                                          ((lambda (lexical-labels-1843)
+                                             ((lambda (lexical-new-w-1844)
+                                                ((lambda (lexical-b*-1845)
+                                                   (values
+                                                    (cons lexical-e1-1839
+                                                          lexical-e2-1840)
+                                                    (lexical-extend-env*-323
+                                                     lexical-labels-1843
+                                                     lexical-b*-1845
+                                                     lexical-r-1830)
+                                                    (lexical-extend-env*-323
+                                                     lexical-labels-1843
+                                                     lexical-b*-1845
+                                                     lexical-mr-1831)
+                                                    lexical-new-w-1844
+                                                    lexical-ae-1833))
+                                                 ((lambda (lexical-w-1847)
+                                                    (map (lambda (lexical-x-1848)
+                                                           (lexical-defer-or-eval-transformer-330
+                                                            lexical-local-eval-hook-160
+                                                            (lexical-chi-525
+                                                             lexical-x-1848
+                                                             lexical-mr-1831
+                                                             lexical-mr-1831
+                                                             lexical-w-1847
+                                                             '#t)))
+                                                         lexical-val-1838))
+                                                  (if lexical-rec?-1828
+                                                      lexical-new-w-1844
+                                                      lexical-w-1832))))
+                                              (lexical-make-binding-wrap-444
+                                               lexical-ids-1841
+                                               lexical-labels-1843
+                                               lexical-w-1832)))
+                                           (lexical-gen-labels-391
+                                            lexical-ids-1841))))
+                                    lexical-id-1837))
+                                 lexical-tmp-1835)
+                          ((lambda (lexical-_-1851)
+                             (syntax-error
+                              (lexical-source-wrap-471
+                               lexical-e-1829
+                               lexical-w-1832
+                               lexical-ae-1833)))
+                           lexical-tmp-1834)))
+                    ($syntax-dispatch
+                     lexical-tmp-1834
+                     '(any #(each (any any)) any . each-any))))
+                 lexical-e-1829)))
+             (lexical-chi-void-546 (lambda () (cons 'void '())))
+             (lexical-ellipsis?-547
+              (lambda (lexical-x-1852)
+                (if (lexical-nonsymbol-id?-332 lexical-x-1852)
+                    (lexical-literal-id=?-463
+                     lexical-x-1852
+                     '#(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
+                            call-or-value
+                            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?
+                            tmp-wrap
+                            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-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
+                            update-import-binding!
+                            get-import-binding
+                            read-only-binding?
+                            put-global-definition-hook
+                            get-global-definition-hook
+                            put-cte-hook
+                            error-hook
+                            define-top-level-value-hook
+                            local-eval-hook
+                            top-level-eval-hook
+                            annotation?
+                            fx>=
+                            fx<=
+                            fx>
+                            fx<
+                            fx=
+                            fx-
+                            fx+
+                            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)
+                            (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)
+                            (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"
+                            "i"
+                            "i"
+                            "i"
+                            "i"
+                            "i"
+                            "i"
+                            "i"
+                            "i"
+                            "i"))
+                         #(top-ribcage *top* #t))))
+                    '#f)))
+             (lexical-strip-annotation-548
+              (lambda (lexical-x-1853)
+                (if (pair? lexical-x-1853)
+                    (cons (lexical-strip-annotation-548 (car lexical-x-1853))
+                          (lexical-strip-annotation-548 (cdr lexical-x-1853)))
+                    (if (lexical-annotation?-158 lexical-x-1853)
+                        (annotation-stripped lexical-x-1853)
+                        lexical-x-1853))))
+             (lexical-strip*-549
+              (lambda (lexical-x-1854 lexical-w-1855 lexical-fn-1856)
+                (if (memq 'top (lexical-wrap-marks-343 lexical-w-1855))
+                    (lexical-fn-1856 lexical-x-1854)
+                    ((letrec ((lexical-f-1857
+                               (lambda (lexical-x-1858)
+                                 (if (lexical-syntax-object?-90 lexical-x-1858)
+                                     (lexical-strip*-549
+                                      (lexical-syntax-object-expression-91
+                                       lexical-x-1858)
+                                      (lexical-syntax-object-wrap-92
+                                       lexical-x-1858)
+                                      lexical-fn-1856)
+                                     (if (pair? lexical-x-1858)
+                                         ((lambda (lexical-a-1859
+                                                   lexical-d-1860)
+                                            (if (if (eq? lexical-a-1859
+                                                         (car lexical-x-1858))
+                                                    (eq? lexical-d-1860
+                                                         (cdr lexical-x-1858))
+                                                    '#f)
+                                                lexical-x-1858
+                                                (cons lexical-a-1859
+                                                      lexical-d-1860)))
+                                          (lexical-f-1857 (car lexical-x-1858))
+                                          (lexical-f-1857 (cdr lexical-x-1858)))
+                                         (if (vector? lexical-x-1858)
+                                             ((lambda (lexical-old-1861)
+                                                ((lambda (lexical-new-1862)
+                                                   (if (andmap
+                                                        eq?
+                                                        lexical-old-1861
+                                                        lexical-new-1862)
+                                                       lexical-x-1858
+                                                       (list->vector
+                                                        lexical-new-1862)))
+                                                 (map lexical-f-1857
+                                                      lexical-old-1861)))
+                                              (vector->list lexical-x-1858))
+                                             lexical-x-1858))))))
+                       lexical-f-1857)
+                     lexical-x-1854))))
+             (lexical-strip-550
+              (lambda (lexical-x-1863 lexical-w-1864)
+                (lexical-strip*-549
+                 lexical-x-1863
+                 lexical-w-1864
+                 (lambda (lexical-x-1865)
+                   (if ((lambda (lexical-t-1866)
+                          (if lexical-t-1866
+                              lexical-t-1866
+                              (if (pair? lexical-x-1865)
+                                  (lexical-annotation?-158
+                                   (car lexical-x-1865))
+                                  '#f)))
+                        (lexical-annotation?-158 lexical-x-1865))
+                       (lexical-strip-annotation-548 lexical-x-1865)
+                       lexical-x-1865)))))
+             (lexical-gen-var-551
+              (lambda (lexical-id-1867)
+                ((lambda (lexical-id-1868)
+                   (if (lexical-annotation?-158 lexical-id-1868)
+                       (gensym (annotation-expression lexical-id-1868))
+                       (gensym lexical-id-1868)))
+                 (if (lexical-syntax-object?-90 lexical-id-1867)
+                     (lexical-syntax-object-expression-91 lexical-id-1867)
+                     lexical-id-1867))))
+             (lexical-lambda-var-list-552
+              (lambda (lexical-vars-1869)
+                ((letrec ((lexical-lvl-1870
+                           (lambda (lexical-vars-1871
+                                    lexical-ls-1872
+                                    lexical-w-1873)
+                             (if (pair? lexical-vars-1871)
+                                 (lexical-lvl-1870
+                                  (cdr lexical-vars-1871)
+                                  (cons (lexical-wrap-470
+                                         (car lexical-vars-1871)
+                                         lexical-w-1873)
+                                        lexical-ls-1872)
+                                  lexical-w-1873)
+                                 (if (lexical-id?-333 lexical-vars-1871)
+                                     (cons (lexical-wrap-470
+                                            lexical-vars-1871
+                                            lexical-w-1873)
+                                           lexical-ls-1872)
+                                     (if (null? lexical-vars-1871)
+                                         lexical-ls-1872
+                                         (if (lexical-syntax-object?-90
+                                              lexical-vars-1871)
+                                             (lexical-lvl-1870
+                                              (lexical-syntax-object-expression-91
+                                               lexical-vars-1871)
+                                              lexical-ls-1872
+                                              (lexical-join-wraps-449
+                                               lexical-w-1873
+                                               (lexical-syntax-object-wrap-92
+                                                lexical-vars-1871)))
+                                             (if (lexical-annotation?-158
+                                                  lexical-vars-1871)
+                                                 (lexical-lvl-1870
+                                                  (annotation-expression
+                                                   lexical-vars-1871)
+                                                  lexical-ls-1872
+                                                  lexical-w-1873)
+                                                 (cons lexical-vars-1871
+                                                       lexical-ls-1872)))))))))
+                   lexical-lvl-1870)
+                 lexical-vars-1869
+                 '()
+                 '(())))))
+     (begin
+       (set! $sc-put-cte
+             (lambda (lexical-id-1874 lexical-b-1875 lexical-top-token-1876)
+               (letrec* ((lexical-sc-put-module-1877
+                          (lambda (lexical-exports-1879
+                                   lexical-token-1880
+                                   lexical-new-marks-1881)
+                            (lexical-vfor-each-515
+                             (lambda (lexical-id-1882)
+                               (lexical-store-import-binding-443
+                                lexical-id-1882
+                                lexical-token-1880
+                                lexical-new-marks-1881))
+                             lexical-exports-1879)))
+                         (lexical-put-cte-1878
+                          (lambda (lexical-id-1883
+                                   lexical-binding-1884
+                                   lexical-token-1885)
+                            ((lambda (lexical-sym-1886)
+                               (begin
+                                 (lexical-store-import-binding-443
+                                  lexical-id-1883
+                                  lexical-token-1885
+                                  '())
+                                 (lexical-put-global-definition-hook-165
+                                  lexical-sym-1886
+                                  (if (if (eq? (lexical-binding-type-308
+                                                lexical-binding-1884)
+                                               'global)
+                                          (eq? (lexical-binding-value-309
+                                                lexical-binding-1884)
+                                               lexical-sym-1886)
+                                          '#f)
+                                      '#f
+                                      lexical-binding-1884))))
+                             (if (symbol? lexical-id-1883)
+                                 lexical-id-1883
+                                 (lexical-id-var-name-461
+                                  lexical-id-1883
+                                  '(())))))))
+                 ((lambda (lexical-binding-1887)
+                    ((lambda (lexical-t-1888)
+                       (if (memv lexical-t-1888 '($module))
+                           (begin
+                             ((lambda (lexical-iface-1889)
+                                (lexical-sc-put-module-1877
+                                 (lexical-interface-exports-481
+                                  lexical-iface-1889)
+                                 (lexical-interface-token-482
+                                  lexical-iface-1889)
+                                 '()))
+                              (lexical-binding-value-309 lexical-binding-1887))
+                             (lexical-put-cte-1878
+                              lexical-id-1874
+                              lexical-binding-1887
+                              lexical-top-token-1876))
+                           (if (memv lexical-t-1888 '(do-alias))
+                               (lexical-store-import-binding-443
+                                lexical-id-1874
+                                lexical-top-token-1876
+                                '())
+                               (if (memv lexical-t-1888 '(do-import))
+                                   ((lambda (lexical-token-1890)
+                                      ((lambda (lexical-b-1891)
+                                         ((lambda (lexical-t-1892)
+                                            (if (memv lexical-t-1892
+                                                      '($module))
+                                                ((lambda (lexical-iface-1893)
+                                                   ((lambda (lexical-exports-1894)
+                                                      ((lambda ()
+                                                         (begin
+                                                           (if (not (eq? (lexical-interface-token-482
+                                                                          lexical-iface-1893)
+                                                                         lexical-token-1890))
+                                                               (syntax-error
+                                                                lexical-id-1874
+                                                                '"import mismatch for module")
+                                                               (void))
+                                                           (lexical-sc-put-module-1877
+                                                            (lexical-interface-exports-481
+                                                             lexical-iface-1893)
+                                                            lexical-top-token-1876
+                                                            (lexical-import-mark-delta-533
+                                                             lexical-id-1874
+                                                             lexical-iface-1893))))))
+                                                    (lexical-interface-exports-481
+                                                     lexical-iface-1893)))
+                                                 (lexical-binding-value-309
+                                                  lexical-b-1891))
+                                                (syntax-error
+                                                 lexical-id-1874
+                                                 '"unknown module")))
+                                          (lexical-binding-type-308
+                                           lexical-b-1891)))
+                                       (lexical-lookup-328
+                                        (lexical-id-var-name-461
+                                         lexical-id-1874
+                                         '(()))
+                                        '())))
+                                    (lexical-binding-value-309 lexical-b-1875))
+                                   (lexical-put-cte-1878
+                                    lexical-id-1874
+                                    lexical-binding-1887
+                                    lexical-top-token-1876)))))
+                     (lexical-binding-type-308 lexical-binding-1887)))
+                  (lexical-make-transformer-binding-329 lexical-b-1875)))))
+       (lexical-global-extend-331 'local-syntax 'letrec-syntax '#t)
+       (lexical-global-extend-331 'local-syntax 'let-syntax '#f)
+       (lexical-global-extend-331
+        'core
+        'fluid-let-syntax
+        (lambda (lexical-e-1895
+                 lexical-r-1896
+                 lexical-mr-1897
+                 lexical-w-1898
+                 lexical-ae-1899
+                 lexical-m?-1900)
+          ((lambda (lexical-tmp-1901)
+             ((lambda (lexical-tmp-1902)
+                (if (if lexical-tmp-1902
+                        (apply (lambda (lexical-_-1903
+                                        lexical-var-1904
+                                        lexical-val-1905
+                                        lexical-e1-1906
+                                        lexical-e2-1907)
+                                 (lexical-valid-bound-ids?-466
+                                  lexical-var-1904))
+                               lexical-tmp-1902)
+                        '#f)
+                    (apply (lambda (lexical-_-1909
+                                    lexical-var-1910
+                                    lexical-val-1911
+                                    lexical-e1-1912
+                                    lexical-e2-1913)
+                             ((lambda (lexical-names-1914)
+                                (begin
+                                  (for-each
+                                   (lambda (lexical-id-1915 lexical-n-1916)
+                                     ((lambda (lexical-t-1917)
+                                        (if (memv lexical-t-1917
+                                                  '(displaced-lexical))
+                                            (lexical-displaced-lexical-error-326
+                                             (lexical-wrap-470
+                                              lexical-id-1915
+                                              lexical-w-1898))
+                                            (void)))
+                                      (lexical-binding-type-308
+                                       (lexical-lookup-328
+                                        lexical-n-1916
+                                        lexical-r-1896))))
+                                   lexical-var-1910
+                                   lexical-names-1914)
+                                  ((lambda (lexical-b*-1919)
+                                     (lexical-chi-body-531
+                                      (cons lexical-e1-1912 lexical-e2-1913)
+                                      (lexical-source-wrap-471
+                                       lexical-e-1895
+                                       lexical-w-1898
+                                       lexical-ae-1899)
+                                      (lexical-extend-env*-323
+                                       lexical-names-1914
+                                       lexical-b*-1919
+                                       lexical-r-1896)
+                                      (lexical-extend-env*-323
+                                       lexical-names-1914
+                                       lexical-b*-1919
+                                       lexical-mr-1897)
+                                      lexical-w-1898
+                                      lexical-m?-1900))
+                                   (map (lambda (lexical-x-1921)
+                                          (lexical-defer-or-eval-transformer-330
+                                           lexical-local-eval-hook-160
+                                           (lexical-chi-525
+                                            lexical-x-1921
+                                            lexical-mr-1897
+                                            lexical-mr-1897
+                                            lexical-w-1898
+                                            '#t)))
+                                        lexical-val-1911))))
+                              (map (lambda (lexical-x-1923)
+                                     (lexical-id-var-name-461
+                                      lexical-x-1923
+                                      lexical-w-1898))
+                                   lexical-var-1910)))
+                           lexical-tmp-1902)
+                    ((lambda (lexical-_-1925)
+                       (syntax-error
+                        (lexical-source-wrap-471
+                         lexical-e-1895
+                         lexical-w-1898
+                         lexical-ae-1899)))
+                     lexical-tmp-1901)))
+              ($syntax-dispatch
+               lexical-tmp-1901
+               '(any #(each (any any)) any . each-any))))
+           lexical-e-1895)))
+       (lexical-global-extend-331
+        'core
+        'quote
+        (lambda (lexical-e-1926
+                 lexical-r-1927
+                 lexical-mr-1928
+                 lexical-w-1929
+                 lexical-ae-1930
+                 lexical-m?-1931)
+          ((lambda (lexical-tmp-1932)
+             ((lambda (lexical-tmp-1933)
+                (if lexical-tmp-1933
+                    (apply (lambda (lexical-_-1934 lexical-e-1935)
+                             (list 'quote
+                                   (lexical-strip-550
+                                    lexical-e-1935
+                                    lexical-w-1929)))
+                           lexical-tmp-1933)
+                    ((lambda (lexical-_-1936)
+                       (syntax-error
+                        (lexical-source-wrap-471
+                         lexical-e-1926
+                         lexical-w-1929
+                         lexical-ae-1930)))
+                     lexical-tmp-1932)))
+              ($syntax-dispatch lexical-tmp-1932 '(any any))))
+           lexical-e-1926)))
+       (lexical-global-extend-331
+        'core
+        'syntax
+        ((lambda ()
+           (letrec* ((lexical-gen-syntax-1937
+                      (lambda (lexical-src-1945
+                               lexical-e-1946
+                               lexical-r-1947
+                               lexical-maps-1948
+                               lexical-ellipsis?-1949
+                               lexical-vec?-1950)
+                        (if (lexical-id?-333 lexical-e-1946)
+                            ((lambda (lexical-label-1951)
+                               ((lambda (lexical-b-1952)
+                                  (if (eq? (lexical-binding-type-308
+                                            lexical-b-1952)
+                                           'syntax)
+                                      (call-with-values
+                                       (lambda ()
+                                         ((lambda (lexical-var.lev-1953)
+                                            (lexical-gen-ref-1938
+                                             lexical-src-1945
+                                             (car lexical-var.lev-1953)
+                                             (cdr lexical-var.lev-1953)
+                                             lexical-maps-1948))
+                                          (lexical-binding-value-309
+                                           lexical-b-1952)))
+                                       (lambda (lexical-var-1954
+                                                lexical-maps-1955)
+                                         (values
+                                          (list 'ref lexical-var-1954)
+                                          lexical-maps-1955)))
+                                      (if (lexical-ellipsis?-1949
+                                           lexical-e-1946)
+                                          (syntax-error
+                                           lexical-src-1945
+                                           '"misplaced ellipsis in syntax form")
+                                          (values
+                                           (list 'quote lexical-e-1946)
+                                           lexical-maps-1948))))
+                                (lexical-lookup-328
+                                 lexical-label-1951
+                                 lexical-r-1947)))
+                             (lexical-id-var-name-461 lexical-e-1946 '(())))
+                            ((lambda (lexical-tmp-1956)
+                               ((lambda (lexical-tmp-1957)
+                                  (if (if lexical-tmp-1957
+                                          (apply (lambda (lexical-dots-1958
+                                                          lexical-e-1959)
+                                                   (lexical-ellipsis?-1949
+                                                    lexical-dots-1958))
+                                                 lexical-tmp-1957)
+                                          '#f)
+                                      (apply (lambda (lexical-dots-1960
+                                                      lexical-e-1961)
+                                               (if lexical-vec?-1950
+                                                   (syntax-error
+                                                    lexical-src-1945
+                                                    '"misplaced ellipsis in syntax template")
+                                                   (lexical-gen-syntax-1937
+                                                    lexical-src-1945
+                                                    lexical-e-1961
+                                                    lexical-r-1947
+                                                    lexical-maps-1948
+                                                    (lambda (lexical-x-1962)
+                                                      '#f)
+                                                    '#f)))
+                                             lexical-tmp-1957)
+                                      ((lambda (lexical-tmp-1963)
+                                         (if (if lexical-tmp-1963
+                                                 (apply (lambda (lexical-x-1964
+                                                                 lexical-dots-1965
+                                                                 lexical-y-1966)
+                                                          (lexical-ellipsis?-1949
+                                                           lexical-dots-1965))
+                                                        lexical-tmp-1963)
+                                                 '#f)
+                                             (apply (lambda (lexical-x-1967
+                                                             lexical-dots-1968
+                                                             lexical-y-1969)
+                                                      ((letrec ((lexical-f-1970
+                                                                 (lambda (lexical-y-1971
+                                                                          lexical-k-1972)
+                                                                   ((lambda (lexical-tmp-1973)
+                                                                      ((lambda (lexical-tmp-1974)
+                                                                         (if (if lexical-tmp-1974
+                                                                                 (apply (lambda (lexical-dots-1975
+                                                                                                 lexical-y-1976)
+                                                                                          (lexical-ellipsis?-1949
+                                                                                           lexical-dots-1975))
+                                                                                        lexical-tmp-1974)
+                                                                                 '#f)
+                                                                             (apply (lambda (lexical-dots-1977
+                                                                                             lexical-y-1978)
+                                                                                      (lexical-f-1970
+                                                                                       lexical-y-1978
+                                                                                       (lambda (lexical-maps-1979)
+                                                                                         (call-with-values
+                                                                                          (lambda ()
+                                                                                            (lexical-k-1972
+                                                                                             (cons '()
+                                                                                                   lexical-maps-1979)))
+                                                                                          (lambda (lexical-x-1980
+                                                                                                   lexical-maps-1981)
+                                                                                            (if (null? (car lexical-maps-1981))
+                                                                                                (syntax-error
+                                                                                                 lexical-src-1945
+                                                                                                 '"extra ellipsis in syntax form")
+                                                                                                (values
+                                                                                                 (lexical-gen-mappend-1940
+                                                                                                  lexical-x-1980
+                                                                                                  (car lexical-maps-1981))
+                                                                                                 (cdr lexical-maps-1981))))))))
+                                                                                    lexical-tmp-1974)
+                                                                             ((lambda (lexical-_-1982)
+                                                                                (call-with-values
+                                                                                 (lambda ()
+                                                                                   (lexical-gen-syntax-1937
+                                                                                    lexical-src-1945
+                                                                                    lexical-y-1971
+                                                                                    lexical-r-1947
+                                                                                    lexical-maps-1948
+                                                                                    lexical-ellipsis?-1949
+                                                                                    lexical-vec?-1950))
+                                                                                 (lambda (lexical-y-1983
+                                                                                          lexical-maps-1984)
+                                                                                   (call-with-values
+                                                                                    (lambda ()
+                                                                                      (lexical-k-1972
+                                                                                       lexical-maps-1984))
+                                                                                    (lambda (lexical-x-1985
+                                                                                             lexical-maps-1986)
+                                                                                      (values
+                                                                                       (lexical-gen-append-1939
+                                                                                        lexical-x-1985
+                                                                                        lexical-y-1983)
+                                                                                       lexical-maps-1986))))))
+                                                                              lexical-tmp-1973)))
+                                                                       ($syntax-dispatch
+                                                                        lexical-tmp-1973
+                                                                        '(any .
+                                                                              any))))
+                                                                    lexical-y-1971))))
+                                                         lexical-f-1970)
+                                                       lexical-y-1969
+                                                       (lambda (lexical-maps-1987)
+                                                         (call-with-values
+                                                          (lambda ()
+                                                            (lexical-gen-syntax-1937
+                                                             lexical-src-1945
+                                                             lexical-x-1967
+                                                             lexical-r-1947
+                                                             (cons '()
+                                                                   lexical-maps-1987)
+                                                             lexical-ellipsis?-1949
+                                                             '#f))
+                                                          (lambda (lexical-x-1988
+                                                                   lexical-maps-1989)
+                                                            (if (null? (car lexical-maps-1989))
+                                                                (syntax-error
+                                                                 lexical-src-1945
+                                                                 '"extra ellipsis in syntax form")
+                                                                (values
+                                                                 (lexical-gen-map-1941
+                                                                  lexical-x-1988
+                                                                  (car lexical-maps-1989))
+                                                                 (cdr lexical-maps-1989))))))))
+                                                    lexical-tmp-1963)
+                                             ((lambda (lexical-tmp-1990)
+                                                (if lexical-tmp-1990
+                                                    (apply (lambda (lexical-x-1991
+                                                                    lexical-y-1992)
+                                                             (call-with-values
+                                                              (lambda ()
+                                                                (lexical-gen-syntax-1937
+                                                                 lexical-src-1945
+                                                                 lexical-x-1991
+                                                                 lexical-r-1947
+                                                                 lexical-maps-1948
+                                                                 lexical-ellipsis?-1949
+                                                                 '#f))
+                                                              (lambda (lexical-xnew-1993
+                                                                       lexical-maps-1994)
+                                                                (call-with-values
+                                                                 (lambda ()
+                                                                   (lexical-gen-syntax-1937
+                                                                    lexical-src-1945
+                                                                    lexical-y-1992
+                                                                    lexical-r-1947
+                                                                    lexical-maps-1994
+                                                                    lexical-ellipsis?-1949
+                                                                    lexical-vec?-1950))
+                                                                 (lambda (lexical-ynew-1995
+                                                                          lexical-maps-1996)
+                                                                   (values
+                                                                    (lexical-gen-cons-1942
+                                                                     lexical-e-1946
+                                                                     lexical-x-1991
+                                                                     lexical-y-1992
+                                                                     lexical-xnew-1993
+                                                                     lexical-ynew-1995)
+                                                                    lexical-maps-1996))))))
+                                                           lexical-tmp-1990)
+                                                    ((lambda (lexical-tmp-1997)
+                                                       (if lexical-tmp-1997
+                                                           (apply (lambda (lexical-x1-1998
+                                                                           lexical-x2-1999)
+                                                                    ((lambda (lexical-ls-2000)
+                                                                       (call-with-values
+                                                                        (lambda ()
+                                                                          (lexical-gen-syntax-1937
+                                                                           lexical-src-1945
+                                                                           lexical-ls-2000
+                                                                           lexical-r-1947
+                                                                           lexical-maps-1948
+                                                                           lexical-ellipsis?-1949
+                                                                           '#t))
+                                                                        (lambda (lexical-lsnew-2001
+                                                                                 lexical-maps-2002)
+                                                                          (values
+                                                                           (lexical-gen-vector-1943
+                                                                            lexical-e-1946
+                                                                            lexical-ls-2000
+                                                                            lexical-lsnew-2001)
+                                                                           lexical-maps-2002))))
+                                                                     (cons lexical-x1-1998
+                                                                           lexical-x2-1999)))
+                                                                  lexical-tmp-1997)
+                                                           ((lambda (lexical-_-2004)
+                                                              (values
+                                                               (list 'quote
+                                                                     lexical-e-1946)
+                                                               lexical-maps-1948))
+                                                            lexical-tmp-1956)))
+                                                     ($syntax-dispatch
+                                                      lexical-tmp-1956
+                                                      '#(vector
+                                                         (any . each-any))))))
+                                              ($syntax-dispatch
+                                               lexical-tmp-1956
+                                               '(any . any)))))
+                                       ($syntax-dispatch
+                                        lexical-tmp-1956
+                                        '(any any . any)))))
+                                ($syntax-dispatch lexical-tmp-1956 '(any any))))
+                             lexical-e-1946))))
+                     (lexical-gen-ref-1938
+                      (lambda (lexical-src-2005
+                               lexical-var-2006
+                               lexical-level-2007
+                               lexical-maps-2008)
+                        (if (= lexical-level-2007 '0)
+                            (values lexical-var-2006 lexical-maps-2008)
+                            (if (null? lexical-maps-2008)
+                                (syntax-error
+                                 lexical-src-2005
+                                 '"missing ellipsis in syntax form")
+                                (call-with-values
+                                 (lambda ()
+                                   (lexical-gen-ref-1938
+                                    lexical-src-2005
+                                    lexical-var-2006
+                                    (- lexical-level-2007 '1)
+                                    (cdr lexical-maps-2008)))
+                                 (lambda (lexical-outer-var-2009
+                                          lexical-outer-maps-2010)
+                                   ((lambda (lexical-b-2011)
+                                      (if lexical-b-2011
+                                          (values
+                                           (cdr lexical-b-2011)
+                                           lexical-maps-2008)
+                                          ((lambda (lexical-inner-var-2012)
+                                             (values
+                                              lexical-inner-var-2012
+                                              (cons (cons (cons lexical-outer-var-2009
+                                                                lexical-inner-var-2012)
+                                                          (car lexical-maps-2008))
+                                                    lexical-outer-maps-2010)))
+                                           (lexical-gen-var-551 'tmp))))
+                                    (assq lexical-outer-var-2009
+                                          (car lexical-maps-2008)))))))))
+                     (lexical-gen-append-1939
+                      (lambda (lexical-x-2013 lexical-y-2014)
+                        (if (equal? lexical-y-2014 ''())
+                            lexical-x-2013
+                            (list 'append lexical-x-2013 lexical-y-2014))))
+                     (lexical-gen-mappend-1940
+                      (lambda (lexical-e-2015 lexical-map-env-2016)
+                        (list 'apply
+                              '(primitive append)
+                              (lexical-gen-map-1941
+                               lexical-e-2015
+                               lexical-map-env-2016))))
+                     (lexical-gen-map-1941
+                      (lambda (lexical-e-2017 lexical-map-env-2018)
+                        ((lambda (lexical-formals-2019 lexical-actuals-2020)
+                           (if (eq? (car lexical-e-2017) 'ref)
+                               (car lexical-actuals-2020)
+                               (if (andmap
+                                    (lambda (lexical-x-2021)
+                                      (if (eq? (car lexical-x-2021) 'ref)
+                                          (memq (cadr lexical-x-2021)
+                                                lexical-formals-2019)
+                                          '#f))
+                                    (cdr lexical-e-2017))
+                                   (cons 'map
+                                         (cons (list 'primitive
+                                                     (car lexical-e-2017))
+                                               (map ((lambda (lexical-r-2022)
+                                                       (lambda (lexical-x-2023)
+                                                         (cdr (assq (cadr lexical-x-2023)
+                                                                    lexical-r-2022))))
+                                                     (map cons
+                                                          lexical-formals-2019
+                                                          lexical-actuals-2020))
+                                                    (cdr lexical-e-2017))))
+                                   (cons 'map
+                                         (cons (list 'lambda
+                                                     lexical-formals-2019
+                                                     lexical-e-2017)
+                                               lexical-actuals-2020)))))
+                         (map cdr lexical-map-env-2018)
+                         (map (lambda (lexical-x-2024)
+                                (list 'ref (car lexical-x-2024)))
+                              lexical-map-env-2018))))
+                     (lexical-gen-cons-1942
+                      (lambda (lexical-e-2025
+                               lexical-x-2026
+                               lexical-y-2027
+                               lexical-xnew-2028
+                               lexical-ynew-2029)
+                        ((lambda (lexical-t-2030)
+                           (if (memv lexical-t-2030 '(quote))
+                               (if (eq? (car lexical-xnew-2028) 'quote)
+                                   ((lambda (lexical-xnew-2031
+                                             lexical-ynew-2032)
+                                      (if (if (eq? lexical-xnew-2031
+                                                   lexical-x-2026)
+                                              (eq? lexical-ynew-2032
+                                                   lexical-y-2027)
+                                              '#f)
+                                          (list 'quote lexical-e-2025)
+                                          (list 'quote
+                                                (cons lexical-xnew-2031
+                                                      lexical-ynew-2032))))
+                                    (cadr lexical-xnew-2028)
+                                    (cadr lexical-ynew-2029))
+                                   (if (eq? (cadr lexical-ynew-2029) '())
+                                       (list 'list lexical-xnew-2028)
+                                       (list 'cons
+                                             lexical-xnew-2028
+                                             lexical-ynew-2029)))
+                               (if (memv lexical-t-2030 '(list))
+                                   (cons 'list
+                                         (cons lexical-xnew-2028
+                                               (cdr lexical-ynew-2029)))
+                                   (list 'cons
+                                         lexical-xnew-2028
+                                         lexical-ynew-2029))))
+                         (car lexical-ynew-2029))))
+                     (lexical-gen-vector-1943
+                      (lambda (lexical-e-2033
+                               lexical-ls-2034
+                               lexical-lsnew-2035)
+                        (if (eq? (car lexical-lsnew-2035) 'quote)
+                            (if (eq? (cadr lexical-lsnew-2035) lexical-ls-2034)
+                                (list 'quote lexical-e-2033)
+                                (list 'quote
+                                      (list->vector (cadr lexical-lsnew-2035))))
+                            (if (eq? (car lexical-lsnew-2035) 'list)
+                                (cons 'vector (cdr lexical-lsnew-2035))
+                                (list 'list->vector lexical-lsnew-2035)))))
+                     (lexical-regen-1944
+                      (lambda (lexical-x-2036)
+                        ((lambda (lexical-t-2037)
+                           (if (memv lexical-t-2037 '(ref))
+                               (cadr lexical-x-2036)
+                               (if (memv lexical-t-2037 '(primitive))
+                                   (cadr lexical-x-2036)
+                                   (if (memv lexical-t-2037 '(quote))
+                                       (list 'quote (cadr lexical-x-2036))
+                                       (if (memv lexical-t-2037 '(lambda))
+                                           (list 'lambda
+                                                 (cadr lexical-x-2036)
+                                                 (lexical-regen-1944
+                                                  (caddr lexical-x-2036)))
+                                           (if (memv lexical-t-2037 '(map))
+                                               ((lambda (lexical-ls-2038)
+                                                  (cons (if (= (length
+                                                                lexical-ls-2038)
+                                                               '2)
+                                                            'map
+                                                            'map)
+                                                        lexical-ls-2038))
+                                                (map lexical-regen-1944
+                                                     (cdr lexical-x-2036)))
+                                               (cons (car lexical-x-2036)
+                                                     (map lexical-regen-1944
+                                                          (cdr lexical-x-2036)))))))))
+                         (car lexical-x-2036)))))
+             (lambda (lexical-e-2039
+                      lexical-r-2040
+                      lexical-mr-2041
+                      lexical-w-2042
+                      lexical-ae-2043
+                      lexical-m?-2044)
+               ((lambda (lexical-e-2045)
+                  ((lambda (lexical-tmp-2046)
+                     ((lambda (lexical-tmp-2047)
+                        (if lexical-tmp-2047
+                            (apply (lambda (lexical-_-2048 lexical-x-2049)
+                                     (call-with-values
+                                      (lambda ()
+                                        (lexical-gen-syntax-1937
+                                         lexical-e-2045
+                                         lexical-x-2049
+                                         lexical-r-2040
+                                         '()
+                                         lexical-ellipsis?-547
+                                         '#f))
+                                      (lambda (lexical-e-2050
+                                               lexical-maps-2051)
+                                        (lexical-regen-1944 lexical-e-2050))))
+                                   lexical-tmp-2047)
+                            ((lambda (lexical-_-2052)
+                               (syntax-error lexical-e-2045))
+                             lexical-tmp-2046)))
+                      ($syntax-dispatch lexical-tmp-2046 '(any any))))
+                   lexical-e-2045))
+                (lexical-source-wrap-471
+                 lexical-e-2039
+                 lexical-w-2042
+                 lexical-ae-2043)))))))
+       (lexical-global-extend-331
+        'core
+        'lambda
+        (lambda (lexical-e-2053
+                 lexical-r-2054
+                 lexical-mr-2055
+                 lexical-w-2056
+                 lexical-ae-2057
+                 lexical-m?-2058)
+          ((lambda (lexical-tmp-2059)
+             ((lambda (lexical-tmp-2060)
+                (if lexical-tmp-2060
+                    (apply (lambda (lexical-_-2061 lexical-c-2062)
+                             (call-with-values
+                              (lambda ()
+                                (lexical-chi-lambda-clause-544
+                                 (lexical-source-wrap-471
+                                  lexical-e-2053
+                                  lexical-w-2056
+                                  lexical-ae-2057)
+                                 lexical-c-2062
+                                 lexical-r-2054
+                                 lexical-mr-2055
+                                 lexical-w-2056
+                                 lexical-m?-2058))
+                              (lambda (lexical-vars-2063 lexical-body-2064)
+                                (list 'lambda
+                                      lexical-vars-2063
+                                      lexical-body-2064))))
+                           lexical-tmp-2060)
+                    (syntax-error lexical-tmp-2059)))
+              ($syntax-dispatch lexical-tmp-2059 '(any . any))))
+           lexical-e-2053)))
+       ((lambda (lexical-letrec-transformer-2065)
+          (begin
+            (lexical-global-extend-331
+             'core
+             'letrec
+             (lexical-letrec-transformer-2065 lexical-build-letrec-262))
+            (lexical-global-extend-331
+             'core
+             'letrec*
+             (lexical-letrec-transformer-2065 lexical-build-letrec*-263))))
+        (lambda (lexical-build-2066)
+          (lambda (lexical-e-2067
+                   lexical-r-2068
+                   lexical-mr-2069
+                   lexical-w-2070
+                   lexical-ae-2071
+                   lexical-m?-2072)
+            ((lambda (lexical-tmp-2073)
+               ((lambda (lexical-tmp-2074)
+                  (if lexical-tmp-2074
+                      (apply (lambda (lexical-_-2075
+                                      lexical-id-2076
+                                      lexical-val-2077
+                                      lexical-e1-2078
+                                      lexical-e2-2079)
+                               ((lambda (lexical-ids-2080)
+                                  (if (not (lexical-valid-bound-ids?-466
+                                            lexical-ids-2080))
+                                      (lexical-invalid-ids-error-468
+                                       (map (lambda (lexical-x-2081)
+                                              (lexical-wrap-470
+                                               lexical-x-2081
+                                               lexical-w-2070))
+                                            lexical-ids-2080)
+                                       (lexical-source-wrap-471
+                                        lexical-e-2067
+                                        lexical-w-2070
+                                        lexical-ae-2071)
+                                       '"bound variable")
+                                      ((lambda (lexical-labels-2082
+                                                lexical-new-vars-2083)
+                                         ((lambda (lexical-w-2084
+                                                   lexical-r-2085)
+                                            (lexical-build-2066
+                                             lexical-ae-2071
+                                             lexical-new-vars-2083
+                                             (map (lambda (lexical-x-2086)
+                                                    (lexical-chi-525
+                                                     lexical-x-2086
+                                                     lexical-r-2085
+                                                     lexical-mr-2069
+                                                     lexical-w-2084
+                                                     lexical-m?-2072))
+                                                  lexical-val-2077)
+                                             (lexical-chi-body-531
+                                              (cons lexical-e1-2078
+                                                    lexical-e2-2079)
+                                              (lexical-source-wrap-471
+                                               lexical-e-2067
+                                               lexical-w-2084
+                                               lexical-ae-2071)
+                                              lexical-r-2085
+                                              lexical-mr-2069
+                                              lexical-w-2084
+                                              lexical-m?-2072)))
+                                          (lexical-make-binding-wrap-444
+                                           lexical-ids-2080
+                                           lexical-labels-2082
+                                           lexical-w-2070)
+                                          (lexical-extend-var-env*-324
+                                           lexical-labels-2082
+                                           lexical-new-vars-2083
+                                           lexical-r-2068)))
+                                       (lexical-gen-labels-391
+                                        lexical-ids-2080)
+                                       (map lexical-gen-var-551
+                                            lexical-ids-2080))))
+                                lexical-id-2076))
+                             lexical-tmp-2074)
+                      ((lambda (lexical-_-2090)
+                         (syntax-error
+                          (lexical-source-wrap-471
+                           lexical-e-2067
+                           lexical-w-2070
+                           lexical-ae-2071)))
+                       lexical-tmp-2073)))
+                ($syntax-dispatch
+                 lexical-tmp-2073
+                 '(any #(each (any any)) any . each-any))))
+             lexical-e-2067))))
+       (lexical-global-extend-331
+        'core
+        'if
+        (lambda (lexical-e-2091
+                 lexical-r-2092
+                 lexical-mr-2093
+                 lexical-w-2094
+                 lexical-ae-2095
+                 lexical-m?-2096)
+          ((lambda (lexical-tmp-2097)
+             ((lambda (lexical-tmp-2098)
+                (if lexical-tmp-2098
+                    (apply (lambda (lexical-_-2099
+                                    lexical-test-2100
+                                    lexical-then-2101)
+                             (list 'if
+                                   (lexical-chi-525
+                                    lexical-test-2100
+                                    lexical-r-2092
+                                    lexical-mr-2093
+                                    lexical-w-2094
+                                    lexical-m?-2096)
+                                   (lexical-chi-525
+                                    lexical-then-2101
+                                    lexical-r-2092
+                                    lexical-mr-2093
+                                    lexical-w-2094
+                                    lexical-m?-2096)
+                                   (lexical-chi-void-546)))
+                           lexical-tmp-2098)
+                    ((lambda (lexical-tmp-2102)
+                       (if lexical-tmp-2102
+                           (apply (lambda (lexical-_-2103
+                                           lexical-test-2104
+                                           lexical-then-2105
+                                           lexical-else-2106)
+                                    (list 'if
+                                          (lexical-chi-525
+                                           lexical-test-2104
+                                           lexical-r-2092
+                                           lexical-mr-2093
+                                           lexical-w-2094
+                                           lexical-m?-2096)
+                                          (lexical-chi-525
+                                           lexical-then-2105
+                                           lexical-r-2092
+                                           lexical-mr-2093
+                                           lexical-w-2094
+                                           lexical-m?-2096)
+                                          (lexical-chi-525
+                                           lexical-else-2106
+                                           lexical-r-2092
+                                           lexical-mr-2093
+                                           lexical-w-2094
+                                           lexical-m?-2096)))
+                                  lexical-tmp-2102)
+                           ((lambda (lexical-_-2107)
+                              (syntax-error
+                               (lexical-source-wrap-471
+                                lexical-e-2091
+                                lexical-w-2094
+                                lexical-ae-2095)))
+                            lexical-tmp-2097)))
+                     ($syntax-dispatch lexical-tmp-2097 '(any any any any)))))
+              ($syntax-dispatch lexical-tmp-2097 '(any any any))))
+           lexical-e-2091)))
+       (lexical-global-extend-331 'set! 'set! '())
+       (lexical-global-extend-331 'alias 'alias '())
+       (lexical-global-extend-331 'begin 'begin '())
+       (lexical-global-extend-331 '$module-key '$module '())
+       (lexical-global-extend-331 '$import '$import '())
+       (lexical-global-extend-331 'define 'define '())
+       (lexical-global-extend-331 'define-syntax 'define-syntax '())
+       (lexical-global-extend-331 'eval-when 'eval-when '())
+       (lexical-global-extend-331 'meta 'meta '())
+       (lexical-global-extend-331
+        'core
+        'syntax-case
+        ((lambda ()
+           (letrec* ((lexical-convert-pattern-2108
+                      (lambda (lexical-pattern-2112 lexical-keys-2113)
+                        (letrec* ((lexical-cvt*-2114
+                                   (lambda (lexical-p*-2116
+                                            lexical-n-2117
+                                            lexical-ids-2118)
+                                     (if (null? lexical-p*-2116)
+                                         (values '() lexical-ids-2118)
+                                         (call-with-values
+                                          (lambda ()
+                                            (lexical-cvt*-2114
+                                             (cdr lexical-p*-2116)
+                                             lexical-n-2117
+                                             lexical-ids-2118))
+                                          (lambda (lexical-y-2119
+                                                   lexical-ids-2120)
+                                            (call-with-values
+                                             (lambda ()
+                                               (lexical-cvt-2115
+                                                (car lexical-p*-2116)
+                                                lexical-n-2117
+                                                lexical-ids-2120))
+                                             (lambda (lexical-x-2121
+                                                      lexical-ids-2122)
+                                               (values
+                                                (cons lexical-x-2121
+                                                      lexical-y-2119)
+                                                lexical-ids-2122))))))))
+                                  (lexical-cvt-2115
+                                   (lambda (lexical-p-2123
+                                            lexical-n-2124
+                                            lexical-ids-2125)
+                                     (if (lexical-id?-333 lexical-p-2123)
+                                         (if (lexical-bound-id-member?-469
+                                              lexical-p-2123
+                                              lexical-keys-2113)
+                                             (values
+                                              (vector 'free-id lexical-p-2123)
+                                              lexical-ids-2125)
+                                             (values
+                                              'any
+                                              (cons (cons lexical-p-2123
+                                                          lexical-n-2124)
+                                                    lexical-ids-2125)))
+                                         ((lambda (lexical-tmp-2126)
+                                            ((lambda (lexical-tmp-2127)
+                                               (if (if lexical-tmp-2127
+                                                       (apply (lambda (lexical-x-2128
+                                                                       lexical-dots-2129)
+                                                                (lexical-ellipsis?-547
+                                                                 lexical-dots-2129))
+                                                              lexical-tmp-2127)
+                                                       '#f)
+                                                   (apply (lambda (lexical-x-2130
+                                                                   lexical-dots-2131)
+                                                            (call-with-values
+                                                             (lambda ()
+                                                               (lexical-cvt-2115
+                                                                lexical-x-2130
+                                                                (+ lexical-n-2124
+                                                                   '1)
+                                                                lexical-ids-2125))
+                                                             (lambda (lexical-p-2132
+                                                                      lexical-ids-2133)
+                                                               (values
+                                                                (if (eq? lexical-p-2132
+                                                                         'any)
+                                                                    'each-any
+                                                                    (vector
+                                                                     'each
+                                                                     lexical-p-2132))
+                                                                lexical-ids-2133))))
+                                                          lexical-tmp-2127)
+                                                   ((lambda (lexical-tmp-2134)
+                                                      (if (if lexical-tmp-2134
+                                                              (apply (lambda (lexical-x-2135
+                                                                              lexical-dots-2136
+                                                                              lexical-y-2137
+                                                                              lexical-z-2138)
+                                                                       (lexical-ellipsis?-547
+                                                                        lexical-dots-2136))
+                                                                     lexical-tmp-2134)
+                                                              '#f)
+                                                          (apply (lambda (lexical-x-2139
+                                                                          lexical-dots-2140
+                                                                          lexical-y-2141
+                                                                          lexical-z-2142)
+                                                                   (call-with-values
+                                                                    (lambda ()
+                                                                      (lexical-cvt-2115
+                                                                       lexical-z-2142
+                                                                       lexical-n-2124
+                                                                       lexical-ids-2125))
+                                                                    (lambda (lexical-z-2143
+                                                                             lexical-ids-2144)
+                                                                      (call-with-values
+                                                                       (lambda ()
+                                                                         (lexical-cvt*-2114
+                                                                          lexical-y-2141
+                                                                          lexical-n-2124
+                                                                          lexical-ids-2144))
+                                                                       (lambda (lexical-y-2146
+                                                                                lexical-ids-2147)
+                                                                         (call-with-values
+                                                                          (lambda ()
+                                                                            (lexical-cvt-2115
+                                                                             lexical-x-2139
+                                                                             (+ lexical-n-2124
+                                                                                '1)
+                                                                             lexical-ids-2147))
+                                                                          (lambda (lexical-x-2148
+                                                                                   lexical-ids-2149)
+                                                                            (values
+                                                                             (vector
+                                                                              'each+
+                                                                              lexical-x-2148
+                                                                              (reverse
+                                                                               lexical-y-2146)
+                                                                              lexical-z-2143)
+                                                                             lexical-ids-2149))))))))
+                                                                 lexical-tmp-2134)
+                                                          ((lambda (lexical-tmp-2150)
+                                                             (if lexical-tmp-2150
+                                                                 (apply (lambda (lexical-x-2151
+                                                                                 lexical-y-2152)
+                                                                          (call-with-values
+                                                                           (lambda ()
+                                                                             (lexical-cvt-2115
+                                                                              lexical-y-2152
+                                                                              lexical-n-2124
+                                                                              lexical-ids-2125))
+                                                                           (lambda (lexical-y-2153
+                                                                                    lexical-ids-2154)
+                                                                             (call-with-values
+                                                                              (lambda ()
+                                                                                (lexical-cvt-2115
+                                                                                 lexical-x-2151
+                                                                                 lexical-n-2124
+                                                                                 lexical-ids-2154))
+                                                                              (lambda (lexical-x-2155
+                                                                                       lexical-ids-2156)
+                                                                                (values
+                                                                                 (cons lexical-x-2155
+                                                                                       lexical-y-2153)
+                                                                                 lexical-ids-2156))))))
+                                                                        lexical-tmp-2150)
+                                                                 ((lambda (lexical-tmp-2157)
+                                                                    (if lexical-tmp-2157
+                                                                        (apply (lambda ()
+                                                                                 (values
+                                                                                  '()
+                                                                                  lexical-ids-2125))
+                                                                               lexical-tmp-2157)
+                                                                        ((lambda (lexical-tmp-2158)
+                                                                           (if lexical-tmp-2158
+                                                                               (apply (lambda (lexical-x-2159)
+                                                                                        (call-with-values
+                                                                                         (lambda ()
+                                                                                           (lexical-cvt-2115
+                                                                                            lexical-x-2159
+                                                                                            lexical-n-2124
+                                                                                            lexical-ids-2125))
+                                                                                         (lambda (lexical-p-2161
+                                                                                                  lexical-ids-2162)
+                                                                                           (values
+                                                                                            (vector
+                                                                                             'vector
+                                                                                             lexical-p-2161)
+                                                                                            lexical-ids-2162))))
+                                                                                      lexical-tmp-2158)
+                                                                               ((lambda (lexical-x-2163)
+                                                                                  (values
+                                                                                   (vector
+                                                                                    'atom
+                                                                                    (lexical-strip-550
+                                                                                     lexical-p-2123
+                                                                                     '(())))
+                                                                                   lexical-ids-2125))
+                                                                                lexical-tmp-2126)))
+                                                                         ($syntax-dispatch
+                                                                          lexical-tmp-2126
+                                                                          '#(vector
+                                                                             each-any)))))
+                                                                  ($syntax-dispatch
+                                                                   lexical-tmp-2126
+                                                                   '()))))
+                                                           ($syntax-dispatch
+                                                            lexical-tmp-2126
+                                                            '(any . any)))))
+                                                    ($syntax-dispatch
+                                                     lexical-tmp-2126
+                                                     '(any any
+                                                           .
+                                                           #(each+ any () any))))))
+                                             ($syntax-dispatch
+                                              lexical-tmp-2126
+                                              '(any any))))
+                                          lexical-p-2123)))))
+                          (lexical-cvt-2115 lexical-pattern-2112 '0 '()))))
+                     (lexical-build-dispatch-call-2109
+                      (lambda (lexical-pvars-2164
+                               lexical-exp-2165
+                               lexical-y-2166
+                               lexical-r-2167
+                               lexical-mr-2168
+                               lexical-m?-2169)
+                        ((lambda (lexical-ids-2170 lexical-levels-2171)
+                           ((lambda (lexical-labels-2172 lexical-new-vars-2173)
+                              (cons 'apply
+                                    (list (list 'lambda
+                                                lexical-new-vars-2173
+                                                (lexical-chi-525
+                                                 lexical-exp-2165
+                                                 (lexical-extend-env*-323
+                                                  lexical-labels-2172
+                                                  (map (lambda (lexical-var-2174
+                                                                lexical-level-2175)
+                                                         (cons 'syntax
+                                                               (cons lexical-var-2174
+                                                                     lexical-level-2175)))
+                                                       lexical-new-vars-2173
+                                                       (map cdr
+                                                            lexical-pvars-2164))
+                                                  lexical-r-2167)
+                                                 lexical-mr-2168
+                                                 (lexical-make-binding-wrap-444
+                                                  lexical-ids-2170
+                                                  lexical-labels-2172
+                                                  '(()))
+                                                 lexical-m?-2169))
+                                          lexical-y-2166)))
+                            (lexical-gen-labels-391 lexical-ids-2170)
+                            (map lexical-gen-var-551 lexical-ids-2170)))
+                         (map car lexical-pvars-2164)
+                         (map cdr lexical-pvars-2164))))
+                     (lexical-gen-clause-2110
+                      (lambda (lexical-x-2176
+                               lexical-keys-2177
+                               lexical-clauses-2178
+                               lexical-r-2179
+                               lexical-mr-2180
+                               lexical-m?-2181
+                               lexical-pat-2182
+                               lexical-fender-2183
+                               lexical-exp-2184)
+                        (call-with-values
+                         (lambda ()
+                           (lexical-convert-pattern-2108
+                            lexical-pat-2182
+                            lexical-keys-2177))
+                         (lambda (lexical-p-2185 lexical-pvars-2186)
+                           (if (not (lexical-distinct-bound-ids?-467
+                                     (map car lexical-pvars-2186)))
+                               (lexical-invalid-ids-error-468
+                                (map car lexical-pvars-2186)
+                                lexical-pat-2182
+                                '"pattern variable")
+                               (if (not (andmap
+                                         (lambda (lexical-x-2187)
+                                           (not (lexical-ellipsis?-547
+                                                 (car lexical-x-2187))))
+                                         lexical-pvars-2186))
+                                   (syntax-error
+                                    lexical-pat-2182
+                                    '"misplaced ellipsis in syntax-case pattern")
+                                   ((lambda (lexical-y-2188)
+                                      (cons (list 'lambda
+                                                  (list lexical-y-2188)
+                                                  (list 'if
+                                                        ((lambda (lexical-tmp-2198)
+                                                           ((lambda (lexical-tmp-2199)
+                                                              (if lexical-tmp-2199
+                                                                  (apply (lambda ()
+                                                                           lexical-y-2188)
+                                                                         lexical-tmp-2199)
+                                                                  ((lambda (lexical-_-2200)
+                                                                     (list 'if
+                                                                           lexical-y-2188
+                                                                           (lexical-build-dispatch-call-2109
+                                                                            lexical-pvars-2186
+                                                                            lexical-fender-2183
+                                                                            lexical-y-2188
+                                                                            lexical-r-2179
+                                                                            lexical-mr-2180
+                                                                            lexical-m?-2181)
+                                                                           (list 'quote
+                                                                                 '#f)))
+                                                                   lexical-tmp-2198)))
+                                                            ($syntax-dispatch
+                                                             lexical-tmp-2198
+                                                             '#(atom #t))))
+                                                         lexical-fender-2183)
+                                                        (lexical-build-dispatch-call-2109
+                                                         lexical-pvars-2186
+                                                         lexical-exp-2184
+                                                         lexical-y-2188
+                                                         lexical-r-2179
+                                                         lexical-mr-2180
+                                                         lexical-m?-2181)
+                                                        (lexical-gen-syntax-case-2111
+                                                         lexical-x-2176
+                                                         lexical-keys-2177
+                                                         lexical-clauses-2178
+                                                         lexical-r-2179
+                                                         lexical-mr-2180
+                                                         lexical-m?-2181)))
+                                            (list (if (eq? lexical-p-2185 'any)
+                                                      (cons 'list
+                                                            (list lexical-x-2176))
+                                                      (cons '$syntax-dispatch
+                                                            (list lexical-x-2176
+                                                                  (list 'quote
+                                                                        lexical-p-2185)))))))
+                                    (lexical-gen-var-551 'tmp))))))))
+                     (lexical-gen-syntax-case-2111
+                      (lambda (lexical-x-2201
+                               lexical-keys-2202
+                               lexical-clauses-2203
+                               lexical-r-2204
+                               lexical-mr-2205
+                               lexical-m?-2206)
+                        (if (null? lexical-clauses-2203)
+                            (cons 'syntax-error (list lexical-x-2201))
+                            ((lambda (lexical-tmp-2207)
+                               ((lambda (lexical-tmp-2208)
+                                  (if lexical-tmp-2208
+                                      (apply (lambda (lexical-pat-2209
+                                                      lexical-exp-2210)
+                                               (if (if (lexical-id?-333
+                                                        lexical-pat-2209)
+                                                       (if (not (lexical-bound-id-member?-469
+                                                                 lexical-pat-2209
+                                                                 lexical-keys-2202))
+                                                           (not (lexical-ellipsis?-547
+                                                                 lexical-pat-2209))
+                                                           '#f)
+                                                       '#f)
+                                                   ((lambda (lexical-label-2211
+                                                             lexical-var-2212)
+                                                      (cons (list 'lambda
+                                                                  (list lexical-var-2212)
+                                                                  (lexical-chi-525
+                                                                   lexical-exp-2210
+                                                                   (lexical-extend-env-322
+                                                                    lexical-label-2211
+                                                                    (cons 'syntax
+                                                                          (cons lexical-var-2212
+                                                                                '0))
+                                                                    lexical-r-2204)
+                                                                   lexical-mr-2205
+                                                                   (lexical-make-binding-wrap-444
+                                                                    (list lexical-pat-2209)
+                                                                    (list lexical-label-2211)
+                                                                    '(()))
+                                                                   lexical-m?-2206))
+                                                            (list lexical-x-2201)))
+                                                    (lexical-gen-label-389)
+                                                    (lexical-gen-var-551
+                                                     lexical-pat-2209))
+                                                   (lexical-gen-clause-2110
+                                                    lexical-x-2201
+                                                    lexical-keys-2202
+                                                    (cdr lexical-clauses-2203)
+                                                    lexical-r-2204
+                                                    lexical-mr-2205
+                                                    lexical-m?-2206
+                                                    lexical-pat-2209
+                                                    '#t
+                                                    lexical-exp-2210)))
+                                             lexical-tmp-2208)
+                                      ((lambda (lexical-tmp-2213)
+                                         (if lexical-tmp-2213
+                                             (apply (lambda (lexical-pat-2214
+                                                             lexical-fender-2215
+                                                             lexical-exp-2216)
+                                                      (lexical-gen-clause-2110
+                                                       lexical-x-2201
+                                                       lexical-keys-2202
+                                                       (cdr lexical-clauses-2203)
+                                                       lexical-r-2204
+                                                       lexical-mr-2205
+                                                       lexical-m?-2206
+                                                       lexical-pat-2214
+                                                       lexical-fender-2215
+                                                       lexical-exp-2216))
+                                                    lexical-tmp-2213)
+                                             ((lambda (lexical-_-2217)
+                                                (syntax-error
+                                                 (car lexical-clauses-2203)
+                                                 '"invalid syntax-case clause"))
+                                              lexical-tmp-2207)))
+                                       ($syntax-dispatch
+                                        lexical-tmp-2207
+                                        '(any any any)))))
+                                ($syntax-dispatch lexical-tmp-2207 '(any any))))
+                             (car lexical-clauses-2203))))))
+             (lambda (lexical-e-2218
+                      lexical-r-2219
+                      lexical-mr-2220
+                      lexical-w-2221
+                      lexical-ae-2222
+                      lexical-m?-2223)
+               ((lambda (lexical-e-2224)
+                  ((lambda (lexical-tmp-2225)
+                     ((lambda (lexical-tmp-2226)
+                        (if lexical-tmp-2226
+                            (apply (lambda (lexical-_-2227
+                                            lexical-val-2228
+                                            lexical-key-2229
+                                            lexical-m-2230)
+                                     (if (andmap
+                                          (lambda (lexical-x-2231)
+                                            (if (lexical-id?-333
+                                                 lexical-x-2231)
+                                                (not (lexical-ellipsis?-547
+                                                      lexical-x-2231))
+                                                '#f))
+                                          lexical-key-2229)
+                                         ((lambda (lexical-x-2233)
+                                            (cons (list 'lambda
+                                                        (list lexical-x-2233)
+                                                        (lexical-gen-syntax-case-2111
+                                                         lexical-x-2233
+                                                         lexical-key-2229
+                                                         lexical-m-2230
+                                                         lexical-r-2219
+                                                         lexical-mr-2220
+                                                         lexical-m?-2223))
+                                                  (list (lexical-chi-525
+                                                         lexical-val-2228
+                                                         lexical-r-2219
+                                                         lexical-mr-2220
+                                                         '(())
+                                                         lexical-m?-2223))))
+                                          (lexical-gen-var-551 'tmp))
+                                         (syntax-error
+                                          lexical-e-2224
+                                          '"invalid literals list in")))
+                                   lexical-tmp-2226)
+                            (syntax-error lexical-tmp-2225)))
+                      ($syntax-dispatch
+                       lexical-tmp-2225
+                       '(any any each-any . each-any))))
+                   lexical-e-2224))
+                (lexical-source-wrap-471
+                 lexical-e-2218
+                 lexical-w-2221
+                 lexical-ae-2222)))))))
+       (lexical-put-cte-hook-163
+        'module
+        (lambda (lexical-x-2236)
+          (letrec* ((lexical-proper-export?-2237
+                     (lambda (lexical-e-2238)
+                       ((lambda (lexical-tmp-2239)
+                          ((lambda (lexical-tmp-2240)
+                             (if lexical-tmp-2240
+                                 (apply (lambda (lexical-id-2241
+                                                 lexical-e-2242)
+                                          (if (identifier? lexical-id-2241)
+                                              (andmap
+                                               lexical-proper-export?-2237
+                                               lexical-e-2242)
+                                              '#f))
+                                        lexical-tmp-2240)
+                                 ((lambda (lexical-id-2244)
+                                    (identifier? lexical-id-2244))
+                                  lexical-tmp-2239)))
+                           ($syntax-dispatch
+                            lexical-tmp-2239
+                            '(any . each-any))))
+                        lexical-e-2238))))
+            ((lambda (lexical-tmp-2245)
+               ((lambda (lexical-orig-2246)
+                  ((lambda (lexical-tmp-2247)
+                     ((lambda (lexical-tmp-2248)
+                        (if lexical-tmp-2248
+                            (apply (lambda (lexical-_-2249
+                                            lexical-e-2250
+                                            lexical-d-2251)
+                                     (if (andmap
+                                          lexical-proper-export?-2237
+                                          lexical-e-2250)
+                                         (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
+                                                      call-or-value
+                                                      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?
+                                                      tmp-wrap
+                                                      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-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
+                                                      update-import-binding!
+                                                      get-import-binding
+                                                      read-only-binding?
+                                                      put-global-definition-hook
+                                                      get-global-definition-hook
+                                                      put-cte-hook
+                                                      error-hook
+                                                      define-top-level-value-hook
+                                                      local-eval-hook
+                                                      top-level-eval-hook
+                                                      annotation?
+                                                      fx>=
+                                                      fx<=
+                                                      fx>
+                                                      fx<
+                                                      fx=
+                                                      fx-
+                                                      fx+
+                                                      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)
+                                                      (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)
+                                                      (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"
+                                                      "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
+                                                            call-or-value
+                                                            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?
+                                                            tmp-wrap
+                                                            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-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
+                                                            update-import-binding!
+                                                            get-import-binding
+                                                            read-only-binding?
+                                                            put-global-definition-hook
+                                                            get-global-definition-hook
+                                                            put-cte-hook
+                                                            error-hook
+                                                            define-top-level-value-hook
+                                                            local-eval-hook
+                                                            top-level-eval-hook
+                                                            annotation?
+                                                            fx>=
+                                                            fx<=
+                                                            fx>
+                                                            fx<
+                                                            fx=
+                                                            fx-
+                                                            fx+
+                                                            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)
+                                                            (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)
+                                                            (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"
+                                                            "i"
+                                                            "i"
+                                                            "i"
+                                                            "i"
+                                                            "i"
+                                                            "i"
+                                                            "i"
+                                                            "i"
+                                                            "i"))
+                                                         #(top-ribcage
+                                                           *top*
+                                                           #t)))
+                                                     (cons lexical-orig-2246
+                                                           (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
+                                                                        call-or-value
+                                                                        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?
+                                                                        tmp-wrap
+                                                                        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-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
+                                                                        update-import-binding!
+                                                                        get-import-binding
+                                                                        read-only-binding?
+                                                                        put-global-definition-hook
+                                                                        get-global-definition-hook
+                                                                        put-cte-hook
+                                                                        error-hook
+                                                                        define-top-level-value-hook
+                                                                        local-eval-hook
+                                                                        top-level-eval-hook
+                                                                        annotation?
+                                                                        fx>=
+                                                                        fx<=
+                                                                        fx>
+                                                                        fx<
+                                                                        fx=
+                                                                        fx-
+                                                                        fx+
+                                                                        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)
+                                                                        (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)
+                                                                        (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"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"))
+                                                                     #(top-ribcage
+                                                                       *top*
+                                                                       #t)))
+                                                                 (cons lexical-e-2250
+                                                                       lexical-d-2251))))
+                                               (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
+                                                            call-or-value
+                                                            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?
+                                                            tmp-wrap
+                                                            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-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
+                                                            update-import-binding!
+                                                            get-import-binding
+                                                            read-only-binding?
+                                                            put-global-definition-hook
+                                                            get-global-definition-hook
+                                                            put-cte-hook
+                                                            error-hook
+                                                            define-top-level-value-hook
+                                                            local-eval-hook
+                                                            top-level-eval-hook
+                                                            annotation?
+                                                            fx>=
+                                                            fx<=
+                                                            fx>
+                                                            fx<
+                                                            fx=
+                                                            fx-
+                                                            fx+
+                                                            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)
+                                                            (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)
+                                                            (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"
+                                                            "i"
+                                                            "i"
+                                                            "i"
+                                                            "i"
+                                                            "i"
+                                                            "i"
+                                                            "i"
+                                                            "i"
+                                                            "i"))
+                                                         #(top-ribcage
+                                                           *top*
+                                                           #t)))
+                                                     (cons lexical-orig-2246
+                                                           '#(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
+                                                                  call-or-value
+                                                                  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?
+                                                                  tmp-wrap
+                                                                  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-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
+                                                                  update-import-binding!
+                                                                  get-import-binding
+                                                                  read-only-binding?
+                                                                  put-global-definition-hook
+                                                                  get-global-definition-hook
+                                                                  put-cte-hook
+                                                                  error-hook
+                                                                  define-top-level-value-hook
+                                                                  local-eval-hook
+                                                                  top-level-eval-hook
+                                                                  annotation?
+                                                                  fx>=
+                                                                  fx<=
+                                                                  fx>
+                                                                  fx<
+                                                                  fx=
+                                                                  fx-
+                                                                  fx+
+                                                                  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)
+                                                                  (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)
+                                                                  (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"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"))
+                                                               #(top-ribcage
+                                                                 *top*
+                                                                 #t))))))
+                                         (syntax-error
+                                          lexical-x-2236
+                                          '"invalid exports list in")))
+                                   lexical-tmp-2248)
+                            ((lambda (lexical-tmp-2255)
+                               (if (if lexical-tmp-2255
+                                       (apply (lambda (lexical-_-2256
+                                                       lexical-m-2257
+                                                       lexical-e-2258
+                                                       lexical-d-2259)
+                                                (identifier? lexical-m-2257))
+                                              lexical-tmp-2255)
+                                       '#f)
+                                   (apply (lambda (lexical-_-2260
+                                                   lexical-m-2261
+                                                   lexical-e-2262
+                                                   lexical-d-2263)
+                                            (if (andmap
+                                                 lexical-proper-export?-2237
+                                                 lexical-e-2262)
+                                                (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
+                                                             call-or-value
+                                                             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?
+                                                             tmp-wrap
+                                                             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-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
+                                                             update-import-binding!
+                                                             get-import-binding
+                                                             read-only-binding?
+                                                             put-global-definition-hook
+                                                             get-global-definition-hook
+                                                             put-cte-hook
+                                                             error-hook
+                                                             define-top-level-value-hook
+                                                             local-eval-hook
+                                                             top-level-eval-hook
+                                                             annotation?
+                                                             fx>=
+                                                             fx<=
+                                                             fx>
+                                                             fx<
+                                                             fx=
+                                                             fx-
+                                                             fx+
+                                                             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)
+                                                             (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)
+                                                             (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"
+                                                             "i"
+                                                             "i"
+                                                             "i"
+                                                             "i"
+                                                             "i"
+                                                             "i"
+                                                             "i"
+                                                             "i"
+                                                             "i"))
+                                                          #(top-ribcage
+                                                            *top*
+                                                            #t)))
+                                                      (cons lexical-orig-2246
+                                                            (cons lexical-m-2261
+                                                                  (cons lexical-e-2262
+                                                                        lexical-d-2263))))
+                                                (syntax-error
+                                                 lexical-x-2236
+                                                 '"invalid exports list in")))
+                                          lexical-tmp-2255)
+                                   (syntax-error lexical-tmp-2247)))
+                             ($syntax-dispatch
+                              lexical-tmp-2247
+                              '(any any each-any . each-any)))))
+                      ($syntax-dispatch
+                       lexical-tmp-2247
+                       '(any each-any . each-any))))
+                   lexical-x-2236))
+                lexical-tmp-2245))
+             lexical-x-2236))))
+       ((lambda ()
+          (letrec* ((lexical-$module-exports-2267
+                     (lambda (lexical-m-2269 lexical-r-2270)
+                       ((lambda (lexical-b-2271)
+                          ((lambda (lexical-t-2272)
+                             (if (memv lexical-t-2272 '($module))
+                                 ((lambda (lexical-interface-2273)
+                                    ((lambda (lexical-new-marks-2274)
+                                       ((lambda ()
+                                          (lexical-vmap-514
+                                           (lambda (lexical-x-2275)
+                                             ((lambda (lexical-id-2276)
+                                                (lexical-make-syntax-object-89
+                                                 (syntax-object->datum
+                                                  lexical-id-2276)
+                                                 ((lambda (lexical-marks-2277)
+                                                    (lexical-make-wrap-342
+                                                     lexical-marks-2277
+                                                     (if (eq? (car lexical-marks-2277)
+                                                              '#f)
+                                                         (cons 'shift
+                                                               (lexical-wrap-subst-344
+                                                                '((top))))
+                                                         (lexical-wrap-subst-344
+                                                          '((top))))))
+                                                  (lexical-join-marks-450
+                                                   lexical-new-marks-2274
+                                                   (lexical-wrap-marks-343
+                                                    (lexical-syntax-object-wrap-92
+                                                     lexical-id-2276))))))
+                                              (if (pair? lexical-x-2275)
+                                                  (car lexical-x-2275)
+                                                  lexical-x-2275)))
+                                           (lexical-interface-exports-481
+                                            lexical-interface-2273)))))
+                                     (lexical-import-mark-delta-533
+                                      lexical-m-2269
+                                      lexical-interface-2273)))
+                                  (lexical-binding-value-309 lexical-b-2271))
+                                 (if (memv lexical-t-2272 '(displaced-lexical))
+                                     (lexical-displaced-lexical-error-326
+                                      lexical-m-2269)
+                                     (syntax-error
+                                      lexical-m-2269
+                                      '"unknown module"))))
+                           (lexical-binding-type-308 lexical-b-2271)))
+                        (lexical-r-2270 lexical-m-2269))))
+                    (lexical-$import-help-2268
+                     (lambda (lexical-orig-2278 lexical-import-only?-2279)
+                       (lambda (lexical-r-2280)
+                         (letrec* ((lexical-difference-2281
+                                    (lambda (lexical-ls1-2287 lexical-ls2-2288)
+                                      (if (null? lexical-ls1-2287)
+                                          lexical-ls1-2287
+                                          (if (lexical-bound-id-member?-469
+                                               (car lexical-ls1-2287)
+                                               lexical-ls2-2288)
+                                              (lexical-difference-2281
+                                               (cdr lexical-ls1-2287)
+                                               lexical-ls2-2288)
+                                              (cons (car lexical-ls1-2287)
+                                                    (lexical-difference-2281
+                                                     (cdr lexical-ls1-2287)
+                                                     lexical-ls2-2288))))))
+                                   (lexical-prefix-add-2282
+                                    (lambda (lexical-prefix-id-2289)
+                                      ((lambda (lexical-prefix-2290)
+                                         (lambda (lexical-id-2291)
+                                           (datum->syntax-object
+                                            lexical-id-2291
+                                            (string->symbol
+                                             (string-append
+                                              lexical-prefix-2290
+                                              (symbol->string
+                                               (syntax-object->datum
+                                                lexical-id-2291)))))))
+                                       (symbol->string
+                                        (syntax-object->datum
+                                         lexical-prefix-id-2289)))))
+                                   (lexical-prefix-drop-2283
+                                    (lambda (lexical-prefix-id-2292)
+                                      ((lambda (lexical-prefix-2293)
+                                         (lambda (lexical-id-2294)
+                                           ((lambda (lexical-s-2295)
+                                              ((lambda (lexical-np-2296
+                                                        lexical-ns-2297)
+                                                 (begin
+                                                   (if (not (if (>= lexical-ns-2297
+                                                                    lexical-np-2296)
+                                                                (string=?
+                                                                 (substring
+                                                                  lexical-s-2295
+                                                                  '0
+                                                                  lexical-np-2296)
+                                                                 lexical-prefix-2293)
+                                                                '#f))
+                                                       (syntax-error
+                                                        lexical-id-2294
+                                                        (string-append
+                                                         '"missing expected prefix "
+                                                         lexical-prefix-2293))
+                                                       (void))
+                                                   (datum->syntax-object
+                                                    lexical-id-2294
+                                                    (string->symbol
+                                                     (substring
+                                                      lexical-s-2295
+                                                      lexical-np-2296
+                                                      lexical-ns-2297)))))
+                                               (string-length
+                                                lexical-prefix-2293)
+                                               (string-length lexical-s-2295)))
+                                            (symbol->string
+                                             (syntax-object->datum
+                                              lexical-id-2294)))))
+                                       (symbol->string
+                                        (syntax-object->datum
+                                         lexical-prefix-id-2292)))))
+                                   (lexical-gen-mid-2284
+                                    (lambda (lexical-mid-2298)
+                                      (datum->syntax-object
+                                       lexical-mid-2298
+                                       (lexical-generate-id-169
+                                        ((lambda (lexical-x-2299)
+                                           ((lambda (lexical-e-2300)
+                                              (if (lexical-annotation?-158
+                                                   lexical-e-2300)
+                                                  (annotation-expression
+                                                   lexical-e-2300)
+                                                  lexical-e-2300))
+                                            (if (lexical-syntax-object?-90
+                                                 lexical-x-2299)
+                                                (lexical-syntax-object-expression-91
+                                                 lexical-x-2299)
+                                                lexical-x-2299)))
+                                         lexical-mid-2298)))))
+                                   (lexical-modspec-2285
+                                    (lambda (lexical-m-2301
+                                             lexical-exports?-2302)
+                                      ((lambda (lexical-tmp-2303)
+                                         ((lambda (lexical-tmp-2304)
+                                            (if lexical-tmp-2304
+                                                (apply (lambda (lexical-orig-2305
+                                                                lexical-import-only?-2306)
+                                                         ((lambda (lexical-tmp-2307)
+                                                            ((lambda (lexical-tmp-2308)
+                                                               (if (if lexical-tmp-2308
+                                                                       (apply (lambda (lexical-m-2309
+                                                                                       lexical-id-2310)
+                                                                                (andmap
+                                                                                 identifier?
+                                                                                 lexical-id-2310))
+                                                                              lexical-tmp-2308)
+                                                                       '#f)
+                                                                   (apply (lambda (lexical-m-2312
+                                                                                   lexical-id-2313)
+                                                                            (call-with-values
+                                                                             (lambda ()
+                                                                               (lexical-modspec-2285
+                                                                                lexical-m-2312
+                                                                                '#f))
+                                                                             (lambda (lexical-mid-2314
+                                                                                      lexical-d-2315
+                                                                                      lexical-exports-2316)
+                                                                               ((lambda (lexical-tmp-2317)
+                                                                                  ((lambda (lexical-tmp-2318)
+                                                                                     (if lexical-tmp-2318
+                                                                                         (apply (lambda (lexical-d-2319
+                                                                                                         lexical-tmid-2320)
+                                                                                                  (values
+                                                                                                   lexical-mid-2314
+                                                                                                   (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
+                                                                                                                call-or-value
+                                                                                                                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?
+                                                                                                                tmp-wrap
+                                                                                                                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-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
+                                                                                                                update-import-binding!
+                                                                                                                get-import-binding
+                                                                                                                read-only-binding?
+                                                                                                                put-global-definition-hook
+                                                                                                                get-global-definition-hook
+                                                                                                                put-cte-hook
+                                                                                                                error-hook
+                                                                                                                define-top-level-value-hook
+                                                                                                                local-eval-hook
+                                                                                                                top-level-eval-hook
+                                                                                                                annotation?
+                                                                                                                fx>=
+                                                                                                                fx<=
+                                                                                                                fx>
+                                                                                                                fx<
+                                                                                                                fx=
+                                                                                                                fx-
+                                                                                                                fx+
+                                                                                                                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)
+                                                                                                                (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)
+                                                                                                                (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"
+                                                                                                                "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
+                                                                                                                      call-or-value
+                                                                                                                      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?
+                                                                                                                      tmp-wrap
+                                                                                                                      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-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
+                                                                                                                      update-import-binding!
+                                                                                                                      get-import-binding
+                                                                                                                      read-only-binding?
+                                                                                                                      put-global-definition-hook
+                                                                                                                      get-global-definition-hook
+                                                                                                                      put-cte-hook
+                                                                                                                      error-hook
+                                                                                                                      define-top-level-value-hook
+                                                                                                                      local-eval-hook
+                                                                                                                      top-level-eval-hook
+                                                                                                                      annotation?
+                                                                                                                      fx>=
+                                                                                                                      fx<=
+                                                                                                                      fx>
+                                                                                                                      fx<
+                                                                                                                      fx=
+                                                                                                                      fx-
+                                                                                                                      fx+
+                                                                                                                      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)
+                                                                                                                      (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)
+                                                                                                                      (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"
+                                                                                                                      "i"
+                                                                                                                      "i"
+                                                                                                                      "i"
+                                                                                                                      "i"
+                                                                                                                      "i"
+                                                                                                                      "i"
+                                                                                                                      "i"
+                                                                                                                      "i"
+                                                                                                                      "i"))
+                                                                                                                   #(top-ribcage
+                                                                                                                     *top*
+                                                                                                                     #t)))
+                                                                                                               lexical-orig-2305
+                                                                                                               lexical-tmid-2320
+                                                                                                               lexical-id-2313
+                                                                                                               lexical-d-2319)
+                                                                                                         (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
+                                                                                                                      call-or-value
+                                                                                                                      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?
+                                                                                                                      tmp-wrap
+                                                                                                                      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-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
+                                                                                                                      update-import-binding!
+                                                                                                                      get-import-binding
+                                                                                                                      read-only-binding?
+                                                                                                                      put-global-definition-hook
+                                                                                                                      get-global-definition-hook
+                                                                                                                      put-cte-hook
+                                                                                                                      error-hook
+                                                                                                                      define-top-level-value-hook
+                                                                                                                      local-eval-hook
+                                                                                                                      top-level-eval-hook
+                                                                                                                      annotation?
+                                                                                                                      fx>=
+                                                                                                                      fx<=
+                                                                                                                      fx>
+                                                                                                                      fx<
+                                                                                                                      fx=
+                                                                                                                      fx-
+                                                                                                                      fx+
+                                                                                                                      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)
+                                                                                                                      (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)
+                                                                                                                      (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"
+                                                                                                                      "i"
+                                                                                                                      "i"
+                                                                                                                      "i"
+                                                                                                                      "i"
+                                                                                                                      "i"
+                                                                                                                      "i"
+                                                                                                                      "i"
+                                                                                                                      "i"
+                                                                                                                      "i"))
+                                                                                                                   #(top-ribcage
+                                                                                                                     *top*
+                                                                                                                     #t)))
+                                                                                                               lexical-orig-2305
+                                                                                                               lexical-import-only?-2306
+                                                                                                               lexical-tmid-2320))
+                                                                                                   (if lexical-exports?-2302
+                                                                                                       lexical-id-2313
+                                                                                                       '#f)))
+                                                                                                lexical-tmp-2318)
+                                                                                         (syntax-error
+                                                                                          lexical-tmp-2317)))
+                                                                                   ($syntax-dispatch
+                                                                                    lexical-tmp-2317
+                                                                                    '(any any))))
+                                                                                (list lexical-d-2315
+                                                                                      (lexical-gen-mid-2284
+                                                                                       lexical-mid-2314))))))
+                                                                          lexical-tmp-2308)
+                                                                   ((lambda (lexical-tmp-2323)
+                                                                      (if (if lexical-tmp-2323
+                                                                              (apply (lambda (lexical-m-2324
+                                                                                              lexical-id-2325)
+                                                                                       (andmap
+                                                                                        identifier?
+                                                                                        lexical-id-2325))
+                                                                                     lexical-tmp-2323)
+                                                                              '#f)
+                                                                          (apply (lambda (lexical-m-2327
+                                                                                          lexical-id-2328)
+                                                                                   (call-with-values
+                                                                                    (lambda ()
+                                                                                      (lexical-modspec-2285
+                                                                                       lexical-m-2327
+                                                                                       '#t))
+                                                                                    (lambda (lexical-mid-2329
+                                                                                             lexical-d-2330
+                                                                                             lexical-exports-2331)
+                                                                                      ((lambda (lexical-tmp-2332)
+                                                                                         ((lambda (lexical-tmp-2333)
+                                                                                            (if lexical-tmp-2333
+                                                                                                (apply (lambda (lexical-d-2334
+                                                                                                                lexical-tmid-2335
+                                                                                                                lexical-id-2336)
+                                                                                                         (values
+                                                                                                          lexical-mid-2329
+                                                                                                          (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
+                                                                                                                       call-or-value
+                                                                                                                       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?
+                                                                                                                       tmp-wrap
+                                                                                                                       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-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
+                                                                                                                       update-import-binding!
+                                                                                                                       get-import-binding
+                                                                                                                       read-only-binding?
+                                                                                                                       put-global-definition-hook
+                                                                                                                       get-global-definition-hook
+                                                                                                                       put-cte-hook
+                                                                                                                       error-hook
+                                                                                                                       define-top-level-value-hook
+                                                                                                                       local-eval-hook
+                                                                                                                       top-level-eval-hook
+                                                                                                                       annotation?
+                                                                                                                       fx>=
+                                                                                                                       fx<=
+                                                                                                                       fx>
+                                                                                                                       fx<
+                                                                                                                       fx=
+                                                                                                                       fx-
+                                                                                                                       fx+
+                                                                                                                       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)
+                                                                                                                       (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)
+                                                                                                                       (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"
+                                                                                                                       "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
+                                                                                                                             call-or-value
+                                                                                                                             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?
+                                                                                                                             tmp-wrap
+                                                                                                                             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-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
+                                                                                                                             update-import-binding!
+                                                                                                                             get-import-binding
+                                                                                                                             read-only-binding?
+                                                                                                                             put-global-definition-hook
+                                                                                                                             get-global-definition-hook
+                                                                                                                             put-cte-hook
+                                                                                                                             error-hook
+                                                                                                                             define-top-level-value-hook
+                                                                                                                             local-eval-hook
+                                                                                                                             top-level-eval-hook
+                                                                                                                             annotation?
+                                                                                                                             fx>=
+                                                                                                                             fx<=
+                                                                                                                             fx>
+                                                                                                                             fx<
+                                                                                                                             fx=
+                                                                                                                             fx-
+                                                                                                                             fx+
+                                                                                                                             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)
+                                                                                                                             (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)
+                                                                                                                             (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"
+                                                                                                                             "i"
+                                                                                                                             "i"
+                                                                                                                             "i"
+                                                                                                                             "i"
+                                                                                                                             "i"
+                                                                                                                             "i"
+                                                                                                                             "i"
+                                                                                                                             "i"
+                                                                                                                             "i"))
+                                                                                                                          #(top-ribcage
+                                                                                                                            *top*
+                                                                                                                            #t)))
+                                                                                                                      lexical-orig-2305
+                                                                                                                      lexical-tmid-2335
+                                                                                                                      lexical-id-2336
+                                                                                                                      lexical-d-2334)
+                                                                                                                (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
+                                                                                                                             call-or-value
+                                                                                                                             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?
+                                                                                                                             tmp-wrap
+                                                                                                                             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-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
+                                                                                                                             update-import-binding!
+                                                                                                                             get-import-binding
+                                                                                                                             read-only-binding?
+                                                                                                                             put-global-definition-hook
+                                                                                                                             get-global-definition-hook
+                                                                                                                             put-cte-hook
+                                                                                                                             error-hook
+                                                                                                                             define-top-level-value-hook
+                                                                                                                             local-eval-hook
+                                                                                                                             top-level-eval-hook
+                                                                                                                             annotation?
+                                                                                                                             fx>=
+                                                                                                                             fx<=
+                                                                                                                             fx>
+                                                                                                                             fx<
+                                                                                                                             fx=
+                                                                                                                             fx-
+                                                                                                                             fx+
+                                                                                                                             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)
+                                                                                                                             (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)
+                                                                                                                             (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"
+                                                                                                                             "i"
+                                                                                                                             "i"
+                                                                                                                             "i"
+                                                                                                                             "i"
+                                                                                                                             "i"
+                                                                                                                             "i"
+                                                                                                                             "i"
+                                                                                                                             "i"
+                                                                                                                             "i"))
+                                                                                                                          #(top-ribcage
+                                                                                                                            *top*
+                                                                                                                            #t)))
+                                                                                                                      lexical-orig-2305
+                                                                                                                      lexical-import-only?-2306
+                                                                                                                      lexical-tmid-2335))
+                                                                                                          (if lexical-exports?-2302
+                                                                                                              lexical-id-2336
+                                                                                                              '#f)))
+                                                                                                       lexical-tmp-2333)
+                                                                                                (syntax-error
+                                                                                                 lexical-tmp-2332)))
+                                                                                          ($syntax-dispatch
+                                                                                           lexical-tmp-2332
+                                                                                           '(any any
+                                                                                                 each-any))))
+                                                                                       (list lexical-d-2330
+                                                                                             (lexical-gen-mid-2284
+                                                                                              lexical-mid-2329)
+                                                                                             (lexical-difference-2281
+                                                                                              lexical-exports-2331
+                                                                                              lexical-id-2328))))))
+                                                                                 lexical-tmp-2323)
+                                                                          ((lambda (lexical-tmp-2340)
+                                                                             (if (if lexical-tmp-2340
+                                                                                     (apply (lambda (lexical-m-2341
+                                                                                                     lexical-prefix-id-2342)
+                                                                                              (identifier?
+                                                                                               lexical-prefix-id-2342))
+                                                                                            lexical-tmp-2340)
+                                                                                     '#f)
+                                                                                 (apply (lambda (lexical-m-2343
+                                                                                                 lexical-prefix-id-2344)
+                                                                                          (call-with-values
+                                                                                           (lambda ()
+                                                                                             (lexical-modspec-2285
+                                                                                              lexical-m-2343
+                                                                                              '#t))
+                                                                                           (lambda (lexical-mid-2345
+                                                                                                    lexical-d-2346
+                                                                                                    lexical-exports-2347)
+                                                                                             ((lambda (lexical-tmp-2348)
+                                                                                                ((lambda (lexical-tmp-2349)
+                                                                                                   (if lexical-tmp-2349
+                                                                                                       (apply (lambda (lexical-d-2350
+                                                                                                                       lexical-tmid-2351
+                                                                                                                       lexical-old-id-2352
+                                                                                                                       lexical-tmp-2353
+                                                                                                                       lexical-id-2354)
+                                                                                                                (values
+                                                                                                                 lexical-mid-2345
+                                                                                                                 (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
+                                                                                                                              call-or-value
+                                                                                                                              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?
+                                                                                                                              tmp-wrap
+                                                                                                                              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-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
+                                                                                                                              update-import-binding!
+                                                                                                                              get-import-binding
+                                                                                                                              read-only-binding?
+                                                                                                                              put-global-definition-hook
+                                                                                                                              get-global-definition-hook
+                                                                                                                              put-cte-hook
+                                                                                                                              error-hook
+                                                                                                                              define-top-level-value-hook
+                                                                                                                              local-eval-hook
+                                                                                                                              top-level-eval-hook
+                                                                                                                              annotation?
+                                                                                                                              fx>=
+                                                                                                                              fx<=
+                                                                                                                              fx>
+                                                                                                                              fx<
+                                                                                                                              fx=
+                                                                                                                              fx-
+                                                                                                                              fx+
+                                                                                                                              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)
+                                                                                                                              (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)
+                                                                                                                              (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"
+                                                                                                                              "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
+                                                                                                                                    call-or-value
+                                                                                                                                    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?
+                                                                                                                                    tmp-wrap
+                                                                                                                                    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-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
+                                                                                                                                    update-import-binding!
+                                                                                                                                    get-import-binding
+                                                                                                                                    read-only-binding?
+                                                                                                                                    put-global-definition-hook
+                                                                                                                                    get-global-definition-hook
+                                                                                                                                    put-cte-hook
+                                                                                                                                    error-hook
+                                                                                                                                    define-top-level-value-hook
+                                                                                                                                    local-eval-hook
+                                                                                                                                    top-level-eval-hook
+                                                                                                                                    annotation?
+                                                                                                                                    fx>=
+                                                                                                                                    fx<=
+                                                                                                                                    fx>
+                                                                                                                                    fx<
+                                                                                                                                    fx=
+                                                                                                                                    fx-
+                                                                                                                                    fx+
+                                                                                                                                    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)
+                                                                                                                                    (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)
+                                                                                                                                    (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"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"))
+                                                                                                                                 #(top-ribcage
+                                                                                                                                   *top*
+                                                                                                                                   #t)))
+                                                                                                                             (cons lexical-orig-2305
+                                                                                                                                   (cons lexical-tmid-2351
+                                                                                                                                         (cons (map list
+                                                                                                                                                    lexical-id-2354
+                                                                                                                                                    lexical-tmp-2353)
+                                                                                                                                               (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
+                                                                                                                                                                  call-or-value
+                                                                                                                                                                  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?
+                                                                                                                                                                  tmp-wrap
+                                                                                                                                                                  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-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
+                                                                                                                                                                  update-import-binding!
+                                                                                                                                                                  get-import-binding
+                                                                                                                                                                  read-only-binding?
+                                                                                                                                                                  put-global-definition-hook
+                                                                                                                                                                  get-global-definition-hook
+                                                                                                                                                                  put-cte-hook
+                                                                                                                                                                  error-hook
+                                                                                                                                                                  define-top-level-value-hook
+                                                                                                                                                                  local-eval-hook
+                                                                                                                                                                  top-level-eval-hook
+                                                                                                                                                                  annotation?
+                                                                                                                                                                  fx>=
+                                                                                                                                                                  fx<=
+                                                                                                                                                                  fx>
+                                                                                                                                                                  fx<
+                                                                                                                                                                  fx=
+                                                                                                                                                                  fx-
+                                                                                                                                                                  fx+
+                                                                                                                                                                  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)
+                                                                                                                                                                  (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)
+                                                                                                                                                                  (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"
+                                                                                                                                                                  "i"
+                                                                                                                                                                  "i"
+                                                                                                                                                                  "i"
+                                                                                                                                                                  "i"
+                                                                                                                                                                  "i"
+                                                                                                                                                                  "i"
+                                                                                                                                                                  "i"
+                                                                                                                                                                  "i"
+                                                                                                                                                                  "i"))
+                                                                                                                                                               #(top-ribcage
+                                                                                                                                                                 *top*
+                                                                                                                                                                 #t)))
+                                                                                                                                                           (cons lexical-orig-2305
+                                                                                                                                                                 (cons lexical-tmid-2351
+                                                                                                                                                                       (cons (map list
+                                                                                                                                                                                  lexical-tmp-2353
+                                                                                                                                                                                  lexical-old-id-2352)
+                                                                                                                                                                             (cons lexical-d-2350
+                                                                                                                                                                                   (map (lambda (lexical-tmp-2360
+                                                                                                                                                                                                 lexical-tmp-2359)
+                                                                                                                                                                                          (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
+                                                                                                                                                                                                       call-or-value
+                                                                                                                                                                                                       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?
+                                                                                                                                                                                                       tmp-wrap
+                                                                                                                                                                                                       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-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
+                                                                                                                                                                                                       update-import-binding!
+                                                                                                                                                                                                       get-import-binding
+                                                                                                                                                                                                       read-only-binding?
+                                                                                                                                                                                                       put-global-definition-hook
+                                                                                                                                                                                                       get-global-definition-hook
+                                                                                                                                                                                                       put-cte-hook
+                                                                                                                                                                                                       error-hook
+                                                                                                                                                                                                       define-top-level-value-hook
+                                                                                                                                                                                                       local-eval-hook
+                                                                                                                                                                                                       top-level-eval-hook
+                                                                                                                                                                                                       annotation?
+                                                                                                                                                                                                       fx>=
+                                                                                                                                                                                                       fx<=
+                                                                                                                                                                                                       fx>
+                                                                                                                                                                                                       fx<
+                                                                                                                                                                                                       fx=
+                                                                                                                                                                                                       fx-
+                                                                                                                                                                                                       fx+
+                                                                                                                                                                                                       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)
+                                                                                                                                                                                                       (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)
+                                                                                                                                                                                                       (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"
+                                                                                                                                                                                                       "i"
+                                                                                                                                                                                                       "i"
+                                                                                                                                                                                                       "i"
+                                                                                                                                                                                                       "i"
+                                                                                                                                                                                                       "i"
+                                                                                                                                                                                                       "i"
+                                                                                                                                                                                                       "i"
+                                                                                                                                                                                                       "i"
+                                                                                                                                                                                                       "i"))
+                                                                                                                                                                                                    #(top-ribcage
+                                                                                                                                                                                                      *top*
+                                                                                                                                                                                                      #t)))
+                                                                                                                                                                                                lexical-tmp-2359
+                                                                                                                                                                                                lexical-tmp-2360))
+                                                                                                                                                                                        lexical-old-id-2352
+                                                                                                                                                                                        lexical-tmp-2353))))))
+                                                                                                                                                     (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
+                                                                                                                                                                        call-or-value
+                                                                                                                                                                        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?
+                                                                                                                                                                        tmp-wrap
+                                                                                                                                                                        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-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
+                                                                                                                                                                        update-import-binding!
+                                                                                                                                                                        get-import-binding
+                                                                                                                                                                        read-only-binding?
+                                                                                                                                                                        put-global-definition-hook
+                                                                                                                                                                        get-global-definition-hook
+                                                                                                                                                                        put-cte-hook
+                                                                                                                                                                        error-hook
+                                                                                                                                                                        define-top-level-value-hook
+                                                                                                                                                                        local-eval-hook
+                                                                                                                                                                        top-level-eval-hook
+                                                                                                                                                                        annotation?
+                                                                                                                                                                        fx>=
+                                                                                                                                                                        fx<=
+                                                                                                                                                                        fx>
+                                                                                                                                                                        fx<
+                                                                                                                                                                        fx=
+                                                                                                                                                                        fx-
+                                                                                                                                                                        fx+
+                                                                                                                                                                        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)
+                                                                                                                                                                        (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)
+                                                                                                                                                                        (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"
+                                                                                                                                                                        "i"
+                                                                                                                                                                        "i"
+                                                                                                                                                                        "i"
+                                                                                                                                                                        "i"
+                                                                                                                                                                        "i"
+                                                                                                                                                                        "i"
+                                                                                                                                                                        "i"
+                                                                                                                                                                        "i"
+                                                                                                                                                                        "i"))
+                                                                                                                                                                     #(top-ribcage
+                                                                                                                                                                       *top*
+                                                                                                                                                                       #t)))
+                                                                                                                                                                 lexical-orig-2305
+                                                                                                                                                                 lexical-import-only?-2306
+                                                                                                                                                                 lexical-tmid-2351)
+                                                                                                                                                           (map (lambda (lexical-tmp-2362
+                                                                                                                                                                         lexical-tmp-2361)
+                                                                                                                                                                  (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
+                                                                                                                                                                               call-or-value
+                                                                                                                                                                               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?
+                                                                                                                                                                               tmp-wrap
+                                                                                                                                                                               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-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
+                                                                                                                                                                               update-import-binding!
+                                                                                                                                                                               get-import-binding
+                                                                                                                                                                               read-only-binding?
+                                                                                                                                                                               put-global-definition-hook
+                                                                                                                                                                               get-global-definition-hook
+                                                                                                                                                                               put-cte-hook
+                                                                                                                                                                               error-hook
+                                                                                                                                                                               define-top-level-value-hook
+                                                                                                                                                                               local-eval-hook
+                                                                                                                                                                               top-level-eval-hook
+                                                                                                                                                                               annotation?
+                                                                                                                                                                               fx>=
+                                                                                                                                                                               fx<=
+                                                                                                                                                                               fx>
+                                                                                                                                                                               fx<
+                                                                                                                                                                               fx=
+                                                                                                                                                                               fx-
+                                                                                                                                                                               fx+
+                                                                                                                                                                               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)
+                                                                                                                                                                               (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)
+                                                                                                                                                                               (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"
+                                                                                                                                                                               "i"
+                                                                                                                                                                               "i"
+                                                                                                                                                                               "i"
+                                                                                                                                                                               "i"
+                                                                                                                                                                               "i"
+                                                                                                                                                                               "i"
+                                                                                                                                                                               "i"
+                                                                                                                                                                               "i"
+                                                                                                                                                                               "i"))
+                                                                                                                                                                            #(top-ribcage
+                                                                                                                                                                              *top*
+                                                                                                                                                                              #t)))
+                                                                                                                                                                        lexical-tmp-2361
+                                                                                                                                                                        lexical-tmp-2362))
+                                                                                                                                                                lexical-tmp-2353
+                                                                                                                                                                lexical-id-2354)))))))
+                                                                                                                       (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
+                                                                                                                                    call-or-value
+                                                                                                                                    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?
+                                                                                                                                    tmp-wrap
+                                                                                                                                    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-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
+                                                                                                                                    update-import-binding!
+                                                                                                                                    get-import-binding
+                                                                                                                                    read-only-binding?
+                                                                                                                                    put-global-definition-hook
+                                                                                                                                    get-global-definition-hook
+                                                                                                                                    put-cte-hook
+                                                                                                                                    error-hook
+                                                                                                                                    define-top-level-value-hook
+                                                                                                                                    local-eval-hook
+                                                                                                                                    top-level-eval-hook
+                                                                                                                                    annotation?
+                                                                                                                                    fx>=
+                                                                                                                                    fx<=
+                                                                                                                                    fx>
+                                                                                                                                    fx<
+                                                                                                                                    fx=
+                                                                                                                                    fx-
+                                                                                                                                    fx+
+                                                                                                                                    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)
+                                                                                                                                    (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)
+                                                                                                                                    (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"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"))
+                                                                                                                                 #(top-ribcage
+                                                                                                                                   *top*
+                                                                                                                                   #t)))
+                                                                                                                             lexical-orig-2305
+                                                                                                                             lexical-import-only?-2306
+                                                                                                                             lexical-tmid-2351))
+                                                                                                                 (if lexical-exports?-2302
+                                                                                                                     lexical-id-2354
+                                                                                                                     '#f)))
+                                                                                                              lexical-tmp-2349)
+                                                                                                       (syntax-error
+                                                                                                        lexical-tmp-2348)))
+                                                                                                 ($syntax-dispatch
+                                                                                                  lexical-tmp-2348
+                                                                                                  '(any any
+                                                                                                        each-any
+                                                                                                        each-any
+                                                                                                        each-any))))
+                                                                                              (list lexical-d-2346
+                                                                                                    (lexical-gen-mid-2284
+                                                                                                     lexical-mid-2345)
+                                                                                                    lexical-exports-2347
+                                                                                                    (generate-temporaries
+                                                                                                     lexical-exports-2347)
+                                                                                                    (map (lexical-prefix-add-2282
+                                                                                                          lexical-prefix-id-2344)
+                                                                                                         lexical-exports-2347))))))
+                                                                                        lexical-tmp-2340)
+                                                                                 ((lambda (lexical-tmp-2364)
+                                                                                    (if (if lexical-tmp-2364
+                                                                                            (apply (lambda (lexical-m-2365
+                                                                                                            lexical-prefix-id-2366)
+                                                                                                     (identifier?
+                                                                                                      lexical-prefix-id-2366))
+                                                                                                   lexical-tmp-2364)
+                                                                                            '#f)
+                                                                                        (apply (lambda (lexical-m-2367
+                                                                                                        lexical-prefix-id-2368)
+                                                                                                 (call-with-values
+                                                                                                  (lambda ()
+                                                                                                    (lexical-modspec-2285
+                                                                                                     lexical-m-2367
+                                                                                                     '#t))
+                                                                                                  (lambda (lexical-mid-2369
+                                                                                                           lexical-d-2370
+                                                                                                           lexical-exports-2371)
+                                                                                                    ((lambda (lexical-tmp-2372)
+                                                                                                       ((lambda (lexical-tmp-2373)
+                                                                                                          (if lexical-tmp-2373
+                                                                                                              (apply (lambda (lexical-d-2374
+                                                                                                                              lexical-tmid-2375
+                                                                                                                              lexical-old-id-2376
+                                                                                                                              lexical-tmp-2377
+                                                                                                                              lexical-id-2378)
+                                                                                                                       (values
+                                                                                                                        lexical-mid-2369
+                                                                                                                        (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
+                                                                                                                                     call-or-value
+                                                                                                                                     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?
+                                                                                                                                     tmp-wrap
+                                                                                                                                     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-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
+                                                                                                                                     update-import-binding!
+                                                                                                                                     get-import-binding
+                                                                                                                                     read-only-binding?
+                                                                                                                                     put-global-definition-hook
+                                                                                                                                     get-global-definition-hook
+                                                                                                                                     put-cte-hook
+                                                                                                                                     error-hook
+                                                                                                                                     define-top-level-value-hook
+                                                                                                                                     local-eval-hook
+                                                                                                                                     top-level-eval-hook
+                                                                                                                                     annotation?
+                                                                                                                                     fx>=
+                                                                                                                                     fx<=
+                                                                                                                                     fx>
+                                                                                                                                     fx<
+                                                                                                                                     fx=
+                                                                                                                                     fx-
+                                                                                                                                     fx+
+                                                                                                                                     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)
+                                                                                                                                     (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)
+                                                                                                                                     (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"
+                                                                                                                                     "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
+                                                                                                                                           call-or-value
+                                                                                                                                           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?
+                                                                                                                                           tmp-wrap
+                                                                                                                                           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-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
+                                                                                                                                           update-import-binding!
+                                                                                                                                           get-import-binding
+                                                                                                                                           read-only-binding?
+                                                                                                                                           put-global-definition-hook
+                                                                                                                                           get-global-definition-hook
+                                                                                                                                           put-cte-hook
+                                                                                                                                           error-hook
+                                                                                                                                           define-top-level-value-hook
+                                                                                                                                           local-eval-hook
+                                                                                                                                           top-level-eval-hook
+                                                                                                                                           annotation?
+                                                                                                                                           fx>=
+                                                                                                                                           fx<=
+                                                                                                                                           fx>
+                                                                                                                                           fx<
+                                                                                                                                           fx=
+                                                                                                                                           fx-
+                                                                                                                                           fx+
+                                                                                                                                           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)
+                                                                                                                                           (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)
+                                                                                                                                           (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"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"))
+                                                                                                                                        #(top-ribcage
+                                                                                                                                          *top*
+                                                                                                                                          #t)))
+                                                                                                                                    (cons lexical-orig-2305
+                                                                                                                                          (cons lexical-tmid-2375
+                                                                                                                                                (cons (map list
+                                                                                                                                                           lexical-id-2378
+                                                                                                                                                           lexical-tmp-2377)
+                                                                                                                                                      (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
+                                                                                                                                                                         call-or-value
+                                                                                                                                                                         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?
+                                                                                                                                                                         tmp-wrap
+                                                                                                                                                                         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-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
+                                                                                                                                                                         update-import-binding!
+                                                                                                                                                                         get-import-binding
+                                                                                                                                                                         read-only-binding?
+                                                                                                                                                                         put-global-definition-hook
+                                                                                                                                                                         get-global-definition-hook
+                                                                                                                                                                         put-cte-hook
+                                                                                                                                                                         error-hook
+                                                                                                                                                                         define-top-level-value-hook
+                                                                                                                                                                         local-eval-hook
+                                                                                                                                                                         top-level-eval-hook
+                                                                                                                                                                         annotation?
+                                                                                                                                                                         fx>=
+                                                                                                                                                                         fx<=
+                                                                                                                                                                         fx>
+                                                                                                                                                                         fx<
+                                                                                                                                                                         fx=
+                                                                                                                                                                         fx-
+                                                                                                                                                                         fx+
+                                                                                                                                                                         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)
+                                                                                                                                                                         (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)
+                                                                                                                                                                         (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"
+                                                                                                                                                                         "i"
+                                                                                                                                                                         "i"
+                                                                                                                                                                         "i"
+                                                                                                                                                                         "i"
+                                                                                                                                                                         "i"
+                                                                                                                                                                         "i"
+                                                                                                                                                                         "i"
+                                                                                                                                                                         "i"
+                                                                                                                                                                         "i"))
+                                                                                                                                                                      #(top-ribcage
+                                                                                                                                                                        *top*
+                                                                                                                                                                        #t)))
+                                                                                                                                                                  (cons lexical-orig-2305
+                                                                                                                                                                        (cons lexical-tmid-2375
+                                                                                                                                                                              (cons (map list
+                                                                                                                                                                                         lexical-tmp-2377
+                                                                                                                                                                                         lexical-old-id-2376)
+                                                                                                                                                                                    (cons lexical-d-2374
+                                                                                                                                                                                          (map (lambda (lexical-tmp-2384
+                                                                                                                                                                                                        lexical-tmp-2383)
+                                                                                                                                                                                                 (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
+                                                                                                                                                                                                              call-or-value
+                                                                                                                                                                                                              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?
+                                                                                                                                                                                                              tmp-wrap
+                                                                                                                                                                                                              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-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
+                                                                                                                                                                                                              update-import-binding!
+                                                                                                                                                                                                              get-import-binding
+                                                                                                                                                                                                              read-only-binding?
+                                                                                                                                                                                                              put-global-definition-hook
+                                                                                                                                                                                                              get-global-definition-hook
+                                                                                                                                                                                                              put-cte-hook
+                                                                                                                                                                                                              error-hook
+                                                                                                                                                                                                              define-top-level-value-hook
+                                                                                                                                                                                                              local-eval-hook
+                                                                                                                                                                                                              top-level-eval-hook
+                                                                                                                                                                                                              annotation?
+                                                                                                                                                                                                              fx>=
+                                                                                                                                                                                                              fx<=
+                                                                                                                                                                                                              fx>
+                                                                                                                                                                                                              fx<
+                                                                                                                                                                                                              fx=
+                                                                                                                                                                                                              fx-
+                                                                                                                                                                                                              fx+
+                                                                                                                                                                                                              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)
+                                                                                                                                                                                                              (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)
+                                                                                                                                                                                                              (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"
+                                                                                                                                                                                                              "i"
+                                                                                                                                                                                                              "i"
+                                                                                                                                                                                                              "i"
+                                                                                                                                                                                                              "i"
+                                                                                                                                                                                                              "i"
+                                                                                                                                                                                                              "i"
+                                                                                                                                                                                                              "i"
+                                                                                                                                                                                                              "i"
+                                                                                                                                                                                                              "i"))
+                                                                                                                                                                                                           #(top-ribcage
+                                                                                                                                                                                                             *top*
+                                                                                                                                                                                                             #t)))
+                                                                                                                                                                                                       lexical-tmp-2383
+                                                                                                                                                                                                       lexical-tmp-2384))
+                                                                                                                                                                                               lexical-old-id-2376
+                                                                                                                                                                                               lexical-tmp-2377))))))
+                                                                                                                                                            (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
+                                                                                                                                                                               call-or-value
+                                                                                                                                                                               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?
+                                                                                                                                                                               tmp-wrap
+                                                                                                                                                                               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-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
+                                                                                                                                                                               update-import-binding!
+                                                                                                                                                                               get-import-binding
+                                                                                                                                                                               read-only-binding?
+                                                                                                                                                                               put-global-definition-hook
+                                                                                                                                                                               get-global-definition-hook
+                                                                                                                                                                               put-cte-hook
+                                                                                                                                                                               error-hook
+                                                                                                                                                                               define-top-level-value-hook
+                                                                                                                                                                               local-eval-hook
+                                                                                                                                                                               top-level-eval-hook
+                                                                                                                                                                               annotation?
+                                                                                                                                                                               fx>=
+                                                                                                                                                                               fx<=
+                                                                                                                                                                               fx>
+                                                                                                                                                                               fx<
+                                                                                                                                                                               fx=
+                                                                                                                                                                               fx-
+                                                                                                                                                                               fx+
+                                                                                                                                                                               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)
+                                                                                                                                                                               (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)
+                                                                                                                                                                               (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"
+                                                                                                                                                                               "i"
+                                                                                                                                                                               "i"
+                                                                                                                                                                               "i"
+                                                                                                                                                                               "i"
+                                                                                                                                                                               "i"
+                                                                                                                                                                               "i"
+                                                                                                                                                                               "i"
+                                                                                                                                                                               "i"
+                                                                                                                                                                               "i"))
+                                                                                                                                                                            #(top-ribcage
+                                                                                                                                                                              *top*
+                                                                                                                                                                              #t)))
+                                                                                                                                                                        lexical-orig-2305
+                                                                                                                                                                        lexical-import-only?-2306
+                                                                                                                                                                        lexical-tmid-2375)
+                                                                                                                                                                  (map (lambda (lexical-tmp-2386
+                                                                                                                                                                                lexical-tmp-2385)
+                                                                                                                                                                         (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
+                                                                                                                                                                                      call-or-value
+                                                                                                                                                                                      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?
+                                                                                                                                                                                      tmp-wrap
+                                                                                                                                                                                      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-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
+                                                                                                                                                                                      update-import-binding!
+                                                                                                                                                                                      get-import-binding
+                                                                                                                                                                                      read-only-binding?
+                                                                                                                                                                                      put-global-definition-hook
+                                                                                                                                                                                      get-global-definition-hook
+                                                                                                                                                                                      put-cte-hook
+                                                                                                                                                                                      error-hook
+                                                                                                                                                                                      define-top-level-value-hook
+                                                                                                                                                                                      local-eval-hook
+                                                                                                                                                                                      top-level-eval-hook
+                                                                                                                                                                                      annotation?
+                                                                                                                                                                                      fx>=
+                                                                                                                                                                                      fx<=
+                                                                                                                                                                                      fx>
+                                                                                                                                                                                      fx<
+                                                                                                                                                                                      fx=
+                                                                                                                                                                                      fx-
+                                                                                                                                                                                      fx+
+                                                                                                                                                                                      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)
+                                                                                                                                                                                      (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)
+                                                                                                                                                                                      (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"
+                                                                                                                                                                                      "i"
+                                                                                                                                                                                      "i"
+                                                                                                                                                                                      "i"
+                                                                                                                                                                                      "i"
+                                                                                                                                                                                      "i"
+                                                                                                                                                                                      "i"
+                                                                                                                                                                                      "i"
+                                                                                                                                                                                      "i"
+                                                                                                                                                                                      "i"))
+                                                                                                                                                                                   #(top-ribcage
+                                                                                                                                                                                     *top*
+                                                                                                                                                                                     #t)))
+                                                                                                                                                                               lexical-tmp-2385
+                                                                                                                                                                               lexical-tmp-2386))
+                                                                                                                                                                       lexical-tmp-2377
+                                                                                                                                                                       lexical-id-2378)))))))
+                                                                                                                              (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
+                                                                                                                                           call-or-value
+                                                                                                                                           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?
+                                                                                                                                           tmp-wrap
+                                                                                                                                           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-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
+                                                                                                                                           update-import-binding!
+                                                                                                                                           get-import-binding
+                                                                                                                                           read-only-binding?
+                                                                                                                                           put-global-definition-hook
+                                                                                                                                           get-global-definition-hook
+                                                                                                                                           put-cte-hook
+                                                                                                                                           error-hook
+                                                                                                                                           define-top-level-value-hook
+                                                                                                                                           local-eval-hook
+                                                                                                                                           top-level-eval-hook
+                                                                                                                                           annotation?
+                                                                                                                                           fx>=
+                                                                                                                                           fx<=
+                                                                                                                                           fx>
+                                                                                                                                           fx<
+                                                                                                                                           fx=
+                                                                                                                                           fx-
+                                                                                                                                           fx+
+                                                                                                                                           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)
+                                                                                                                                           (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)
+                                                                                                                                           (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"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"))
+                                                                                                                                        #(top-ribcage
+                                                                                                                                          *top*
+                                                                                                                                          #t)))
+                                                                                                                                    lexical-orig-2305
+                                                                                                                                    lexical-import-only?-2306
+                                                                                                                                    lexical-tmid-2375))
+                                                                                                                        (if lexical-exports?-2302
+                                                                                                                            lexical-id-2378
+                                                                                                                            '#f)))
+                                                                                                                     lexical-tmp-2373)
+                                                                                                              (syntax-error
+                                                                                                               lexical-tmp-2372)))
+                                                                                                        ($syntax-dispatch
+                                                                                                         lexical-tmp-2372
+                                                                                                         '(any any
+                                                                                                               each-any
+                                                                                                               each-any
+                                                                                                               each-any))))
+                                                                                                     (list lexical-d-2370
+                                                                                                           (lexical-gen-mid-2284
+                                                                                                            lexical-mid-2369)
+                                                                                                           lexical-exports-2371
+                                                                                                           (generate-temporaries
+                                                                                                            lexical-exports-2371)
+                                                                                                           (map (lexical-prefix-drop-2283
+                                                                                                                 lexical-prefix-id-2368)
+                                                                                                                lexical-exports-2371))))))
+                                                                                               lexical-tmp-2364)
+                                                                                        ((lambda (lexical-tmp-2388)
+                                                                                           (if (if lexical-tmp-2388
+                                                                                                   (apply (lambda (lexical-m-2389
+                                                                                                                   lexical-new-id-2390
+                                                                                                                   lexical-old-id-2391)
+                                                                                                            (if (andmap
+                                                                                                                 identifier?
+                                                                                                                 lexical-new-id-2390)
+                                                                                                                (andmap
+                                                                                                                 identifier?
+                                                                                                                 lexical-old-id-2391)
+                                                                                                                '#f))
+                                                                                                          lexical-tmp-2388)
+                                                                                                   '#f)
+                                                                                               (apply (lambda (lexical-m-2394
+                                                                                                               lexical-new-id-2395
+                                                                                                               lexical-old-id-2396)
+                                                                                                        (call-with-values
+                                                                                                         (lambda ()
+                                                                                                           (lexical-modspec-2285
+                                                                                                            lexical-m-2394
+                                                                                                            '#t))
+                                                                                                         (lambda (lexical-mid-2397
+                                                                                                                  lexical-d-2398
+                                                                                                                  lexical-exports-2399)
+                                                                                                           ((lambda (lexical-tmp-2400)
+                                                                                                              ((lambda (lexical-tmp-2401)
+                                                                                                                 (if lexical-tmp-2401
+                                                                                                                     (apply (lambda (lexical-d-2402
+                                                                                                                                     lexical-tmid-2403
+                                                                                                                                     lexical-tmp-2404
+                                                                                                                                     lexical-other-id-2405)
+                                                                                                                              (values
+                                                                                                                               lexical-mid-2397
+                                                                                                                               (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
+                                                                                                                                            call-or-value
+                                                                                                                                            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?
+                                                                                                                                            tmp-wrap
+                                                                                                                                            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-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
+                                                                                                                                            update-import-binding!
+                                                                                                                                            get-import-binding
+                                                                                                                                            read-only-binding?
+                                                                                                                                            put-global-definition-hook
+                                                                                                                                            get-global-definition-hook
+                                                                                                                                            put-cte-hook
+                                                                                                                                            error-hook
+                                                                                                                                            define-top-level-value-hook
+                                                                                                                                            local-eval-hook
+                                                                                                                                            top-level-eval-hook
+                                                                                                                                            annotation?
+                                                                                                                                            fx>=
+                                                                                                                                            fx<=
+                                                                                                                                            fx>
+                                                                                                                                            fx<
+                                                                                                                                            fx=
+                                                                                                                                            fx-
+                                                                                                                                            fx+
+                                                                                                                                            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)
+                                                                                                                                            (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)
+                                                                                                                                            (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"
+                                                                                                                                            "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
+                                                                                                                                                  call-or-value
+                                                                                                                                                  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?
+                                                                                                                                                  tmp-wrap
+                                                                                                                                                  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-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
+                                                                                                                                                  update-import-binding!
+                                                                                                                                                  get-import-binding
+                                                                                                                                                  read-only-binding?
+                                                                                                                                                  put-global-definition-hook
+                                                                                                                                                  get-global-definition-hook
+                                                                                                                                                  put-cte-hook
+                                                                                                                                                  error-hook
+                                                                                                                                                  define-top-level-value-hook
+                                                                                                                                                  local-eval-hook
+                                                                                                                                                  top-level-eval-hook
+                                                                                                                                                  annotation?
+                                                                                                                                                  fx>=
+                                                                                                                                                  fx<=
+                                                                                                                                                  fx>
+                                                                                                                                                  fx<
+                                                                                                                                                  fx=
+                                                                                                                                                  fx-
+                                                                                                                                                  fx+
+                                                                                                                                                  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)
+                                                                                                                                                  (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)
+                                                                                                                                                  (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"
+                                                                                                                                                  "i"
+                                                                                                                                                  "i"
+                                                                                                                                                  "i"
+                                                                                                                                                  "i"
+                                                                                                                                                  "i"
+                                                                                                                                                  "i"
+                                                                                                                                                  "i"
+                                                                                                                                                  "i"
+                                                                                                                                                  "i"))
+                                                                                                                                               #(top-ribcage
+                                                                                                                                                 *top*
+                                                                                                                                                 #t)))
+                                                                                                                                           (cons lexical-orig-2305
+                                                                                                                                                 (cons lexical-tmid-2403
+                                                                                                                                                       (cons (append
+                                                                                                                                                              (map list
+                                                                                                                                                                   lexical-new-id-2395
+                                                                                                                                                                   lexical-tmp-2404)
+                                                                                                                                                              lexical-other-id-2405)
+                                                                                                                                                             (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
+                                                                                                                                                                                call-or-value
+                                                                                                                                                                                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?
+                                                                                                                                                                                tmp-wrap
+                                                                                                                                                                                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-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
+                                                                                                                                                                                update-import-binding!
+                                                                                                                                                                                get-import-binding
+                                                                                                                                                                                read-only-binding?
+                                                                                                                                                                                put-global-definition-hook
+                                                                                                                                                                                get-global-definition-hook
+                                                                                                                                                                                put-cte-hook
+                                                                                                                                                                                error-hook
+                                                                                                                                                                                define-top-level-value-hook
+                                                                                                                                                                                local-eval-hook
+                                                                                                                                                                                top-level-eval-hook
+                                                                                                                                                                                annotation?
+                                                                                                                                                                                fx>=
+                                                                                                                                                                                fx<=
+                                                                                                                                                                                fx>
+                                                                                                                                                                                fx<
+                                                                                                                                                                                fx=
+                                                                                                                                                                                fx-
+                                                                                                                                                                                fx+
+                                                                                                                                                                                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)
+                                                                                                                                                                                (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)
+                                                                                                                                                                                (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"
+                                                                                                                                                                                "i"
+                                                                                                                                                                                "i"
+                                                                                                                                                                                "i"
+                                                                                                                                                                                "i"
+                                                                                                                                                                                "i"
+                                                                                                                                                                                "i"
+                                                                                                                                                                                "i"
+                                                                                                                                                                                "i"
+                                                                                                                                                                                "i"))
+                                                                                                                                                                             #(top-ribcage
+                                                                                                                                                                               *top*
+                                                                                                                                                                               #t)))
+                                                                                                                                                                         (cons lexical-orig-2305
+                                                                                                                                                                               (cons lexical-tmid-2403
+                                                                                                                                                                                     (cons (append
+                                                                                                                                                                                            lexical-other-id-2405
+                                                                                                                                                                                            (map list
+                                                                                                                                                                                                 lexical-tmp-2404
+                                                                                                                                                                                                 lexical-old-id-2396))
+                                                                                                                                                                                           (cons lexical-d-2402
+                                                                                                                                                                                                 (map (lambda (lexical-tmp-2413
+                                                                                                                                                                                                               lexical-tmp-2412)
+                                                                                                                                                                                                        (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
+                                                                                                                                                                                                                     call-or-value
+                                                                                                                                                                                                                     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?
+                                                                                                                                                                                                                     tmp-wrap
+                                                                                                                                                                                                                     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-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
+                                                                                                                                                                                                                     update-import-binding!
+                                                                                                                                                                                                                     get-import-binding
+                                                                                                                                                                                                                     read-only-binding?
+                                                                                                                                                                                                                     put-global-definition-hook
+                                                                                                                                                                                                                     get-global-definition-hook
+                                                                                                                                                                                                                     put-cte-hook
+                                                                                                                                                                                                                     error-hook
+                                                                                                                                                                                                                     define-top-level-value-hook
+                                                                                                                                                                                                                     local-eval-hook
+                                                                                                                                                                                                                     top-level-eval-hook
+                                                                                                                                                                                                                     annotation?
+                                                                                                                                                                                                                     fx>=
+                                                                                                                                                                                                                     fx<=
+                                                                                                                                                                                                                     fx>
+                                                                                                                                                                                                                     fx<
+                                                                                                                                                                                                                     fx=
+                                                                                                                                                                                                                     fx-
+                                                                                                                                                                                                                     fx+
+                                                                                                                                                                                                                     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)
+                                                                                                                                                                                                                     (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)
+                                                                                                                                                                                                                     (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"
+                                                                                                                                                                                                                     "i"
+                                                                                                                                                                                                                     "i"
+                                                                                                                                                                                                                     "i"
+                                                                                                                                                                                                                     "i"
+                                                                                                                                                                                                                     "i"
+                                                                                                                                                                                                                     "i"
+                                                                                                                                                                                                                     "i"
+                                                                                                                                                                                                                     "i"
+                                                                                                                                                                                                                     "i"))
+                                                                                                                                                                                                                  #(top-ribcage
+                                                                                                                                                                                                                    *top*
+                                                                                                                                                                                                                    #t)))
+                                                                                                                                                                                                              lexical-tmp-2412
+                                                                                                                                                                                                              lexical-tmp-2413))
+                                                                                                                                                                                                      lexical-old-id-2396
+                                                                                                                                                                                                      lexical-tmp-2404))))))
+                                                                                                                                                                   (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
+                                                                                                                                                                                      call-or-value
+                                                                                                                                                                                      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?
+                                                                                                                                                                                      tmp-wrap
+                                                                                                                                                                                      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-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
+                                                                                                                                                                                      update-import-binding!
+                                                                                                                                                                                      get-import-binding
+                                                                                                                                                                                      read-only-binding?
+                                                                                                                                                                                      put-global-definition-hook
+                                                                                                                                                                                      get-global-definition-hook
+                                                                                                                                                                                      put-cte-hook
+                                                                                                                                                                                      error-hook
+                                                                                                                                                                                      define-top-level-value-hook
+                                                                                                                                                                                      local-eval-hook
+                                                                                                                                                                                      top-level-eval-hook
+                                                                                                                                                                                      annotation?
+                                                                                                                                                                                      fx>=
+                                                                                                                                                                                      fx<=
+                                                                                                                                                                                      fx>
+                                                                                                                                                                                      fx<
+                                                                                                                                                                                      fx=
+                                                                                                                                                                                      fx-
+                                                                                                                                                                                      fx+
+                                                                                                                                                                                      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)
+                                                                                                                                                                                      (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)
+                                                                                                                                                                                      (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"
+                                                                                                                                                                                      "i"
+                                                                                                                                                                                      "i"
+                                                                                                                                                                                      "i"
+                                                                                                                                                                                      "i"
+                                                                                                                                                                                      "i"
+                                                                                                                                                                                      "i"
+                                                                                                                                                                                      "i"
+                                                                                                                                                                                      "i"
+                                                                                                                                                                                      "i"))
+                                                                                                                                                                                   #(top-ribcage
+                                                                                                                                                                                     *top*
+                                                                                                                                                                                     #t)))
+                                                                                                                                                                               lexical-orig-2305
+                                                                                                                                                                               lexical-import-only?-2306
+                                                                                                                                                                               lexical-tmid-2403)
+                                                                                                                                                                         (map (lambda (lexical-tmp-2415
+                                                                                                                                                                                       lexical-tmp-2414)
+                                                                                                                                                                                (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
+                                                                                                                                                                                             call-or-value
+                                                                                                                                                                                             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?
+                                                                                                                                                                                             tmp-wrap
+                                                                                                                                                                                             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-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
+                                                                                                                                                                                             update-import-binding!
+                                                                                                                                                                                             get-import-binding
+                                                                                                                                                                                             read-only-binding?
+                                                                                                                                                                                             put-global-definition-hook
+                                                                                                                                                                                             get-global-definition-hook
+                                                                                                                                                                                             put-cte-hook
+                                                                                                                                                                                             error-hook
+                                                                                                                                                                                             define-top-level-value-hook
+                                                                                                                                                                                             local-eval-hook
+                                                                                                                                                                                             top-level-eval-hook
+                                                                                                                                                                                             annotation?
+                                                                                                                                                                                             fx>=
+                                                                                                                                                                                             fx<=
+                                                                                                                                                                                             fx>
+                                                                                                                                                                                             fx<
+                                                                                                                                                                                             fx=
+                                                                                                                                                                                             fx-
+                                                                                                                                                                                             fx+
+                                                                                                                                                                                             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)
+                                                                                                                                                                                             (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)
+                                                                                                                                                                                             (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"
+                                                                                                                                                                                             "i"
+                                                                                                                                                                                             "i"
+                                                                                                                                                                                             "i"
+                                                                                                                                                                                             "i"
+                                                                                                                                                                                             "i"
+                                                                                                                                                                                             "i"
+                                                                                                                                                                                             "i"
+                                                                                                                                                                                             "i"
+                                                                                                                                                                                             "i"))
+                                                                                                                                                                                          #(top-ribcage
+                                                                                                                                                                                            *top*
+                                                                                                                                                                                            #t)))
+                                                                                                                                                                                      lexical-tmp-2414
+                                                                                                                                                                                      lexical-tmp-2415))
+                                                                                                                                                                              lexical-tmp-2404
+                                                                                                                                                                              lexical-new-id-2395)))))))
+                                                                                                                                     (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
+                                                                                                                                                  call-or-value
+                                                                                                                                                  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?
+                                                                                                                                                  tmp-wrap
+                                                                                                                                                  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-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
+                                                                                                                                                  update-import-binding!
+                                                                                                                                                  get-import-binding
+                                                                                                                                                  read-only-binding?
+                                                                                                                                                  put-global-definition-hook
+                                                                                                                                                  get-global-definition-hook
+                                                                                                                                                  put-cte-hook
+                                                                                                                                                  error-hook
+                                                                                                                                                  define-top-level-value-hook
+                                                                                                                                                  local-eval-hook
+                                                                                                                                                  top-level-eval-hook
+                                                                                                                                                  annotation?
+                                                                                                                                                  fx>=
+                                                                                                                                                  fx<=
+                                                                                                                                                  fx>
+                                                                                                                                                  fx<
+                                                                                                                                                  fx=
+                                                                                                                                                  fx-
+                                                                                                                                                  fx+
+                                                                                                                                                  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)
+                                                                                                                                                  (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)
+                                                                                                                                                  (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"
+                                                                                                                                                  "i"
+                                                                                                                                                  "i"
+                                                                                                                                                  "i"
+                                                                                                                                                  "i"
+                                                                                                                                                  "i"
+                                                                                                                                                  "i"
+                                                                                                                                                  "i"
+                                                                                                                                                  "i"
+                                                                                                                                                  "i"))
+                                                                                                                                               #(top-ribcage
+                                                                                                                                                 *top*
+                                                                                                                                                 #t)))
+                                                                                                                                           lexical-orig-2305
+                                                                                                                                           lexical-import-only?-2306
+                                                                                                                                           lexical-tmid-2403))
+                                                                                                                               (if lexical-exports?-2302
+                                                                                                                                   (append
+                                                                                                                                    lexical-new-id-2395
+                                                                                                                                    lexical-other-id-2405)
+                                                                                                                                   '#f)))
+                                                                                                                            lexical-tmp-2401)
+                                                                                                                     (syntax-error
+                                                                                                                      lexical-tmp-2400)))
+                                                                                                               ($syntax-dispatch
+                                                                                                                lexical-tmp-2400
+                                                                                                                '(any any
+                                                                                                                      each-any
+                                                                                                                      each-any))))
+                                                                                                            (list lexical-d-2398
+                                                                                                                  (lexical-gen-mid-2284
+                                                                                                                   lexical-mid-2397)
+                                                                                                                  (generate-temporaries
+                                                                                                                   lexical-old-id-2396)
+                                                                                                                  (lexical-difference-2281
+                                                                                                                   lexical-exports-2399
+                                                                                                                   lexical-old-id-2396))))))
+                                                                                                      lexical-tmp-2388)
+                                                                                               ((lambda (lexical-tmp-2420)
+                                                                                                  (if (if lexical-tmp-2420
+                                                                                                          (apply (lambda (lexical-m-2421
+                                                                                                                          lexical-new-id-2422
+                                                                                                                          lexical-old-id-2423)
+                                                                                                                   (if (andmap
+                                                                                                                        identifier?
+                                                                                                                        lexical-new-id-2422)
+                                                                                                                       (andmap
+                                                                                                                        identifier?
+                                                                                                                        lexical-old-id-2423)
+                                                                                                                       '#f))
+                                                                                                                 lexical-tmp-2420)
+                                                                                                          '#f)
+                                                                                                      (apply (lambda (lexical-m-2426
+                                                                                                                      lexical-new-id-2427
+                                                                                                                      lexical-old-id-2428)
+                                                                                                               (call-with-values
+                                                                                                                (lambda ()
+                                                                                                                  (lexical-modspec-2285
+                                                                                                                   lexical-m-2426
+                                                                                                                   '#t))
+                                                                                                                (lambda (lexical-mid-2429
+                                                                                                                         lexical-d-2430
+                                                                                                                         lexical-exports-2431)
+                                                                                                                  ((lambda (lexical-tmp-2432)
+                                                                                                                     ((lambda (lexical-tmp-2433)
+                                                                                                                        (if lexical-tmp-2433
+                                                                                                                            (apply (lambda (lexical-d-2434
+                                                                                                                                            lexical-tmid-2435
+                                                                                                                                            lexical-other-id-2436)
+                                                                                                                                     (values
+                                                                                                                                      lexical-mid-2429
+                                                                                                                                      (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
+                                                                                                                                                   call-or-value
+                                                                                                                                                   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?
+                                                                                                                                                   tmp-wrap
+                                                                                                                                                   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-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
+                                                                                                                                                   update-import-binding!
+                                                                                                                                                   get-import-binding
+                                                                                                                                                   read-only-binding?
+                                                                                                                                                   put-global-definition-hook
+                                                                                                                                                   get-global-definition-hook
+                                                                                                                                                   put-cte-hook
+                                                                                                                                                   error-hook
+                                                                                                                                                   define-top-level-value-hook
+                                                                                                                                                   local-eval-hook
+                                                                                                                                                   top-level-eval-hook
+                                                                                                                                                   annotation?
+                                                                                                                                                   fx>=
+                                                                                                                                                   fx<=
+                                                                                                                                                   fx>
+                                                                                                                                                   fx<
+                                                                                                                                                   fx=
+                                                                                                                                                   fx-
+                                                                                                                                                   fx+
+                                                                                                                                                   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)
+                                                                                                                                                   (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)
+                                                                                                                                                   (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"
+                                                                                                                                                   "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
+                                                                                                                                                         call-or-value
+                                                                                                                                                         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?
+                                                                                                                                                         tmp-wrap
+                                                                                                                                                         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-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
+                                                                                                                                                         update-import-binding!
+                                                                                                                                                         get-import-binding
+                                                                                                                                                         read-only-binding?
+                                                                                                                                                         put-global-definition-hook
+                                                                                                                                                         get-global-definition-hook
+                                                                                                                                                         put-cte-hook
+                                                                                                                                                         error-hook
+                                                                                                                                                         define-top-level-value-hook
+                                                                                                                                                         local-eval-hook
+                                                                                                                                                         top-level-eval-hook
+                                                                                                                                                         annotation?
+                                                                                                                                                         fx>=
+                                                                                                                                                         fx<=
+                                                                                                                                                         fx>
+                                                                                                                                                         fx<
+                                                                                                                                                         fx=
+                                                                                                                                                         fx-
+                                                                                                                                                         fx+
+                                                                                                                                                         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)
+                                                                                                                                                         (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)
+                                                                                                                                                         (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"
+                                                                                                                                                         "i"
+                                                                                                                                                         "i"
+                                                                                                                                                         "i"
+                                                                                                                                                         "i"
+                                                                                                                                                         "i"
+                                                                                                                                                         "i"
+                                                                                                                                                         "i"
+                                                                                                                                                         "i"
+                                                                                                                                                         "i"))
+                                                                                                                                                      #(top-ribcage
+                                                                                                                                                        *top*
+                                                                                                                                                        #t)))
+                                                                                                                                                  (cons lexical-orig-2305
+                                                                                                                                                        (cons lexical-tmid-2435
+                                                                                                                                                              (cons (append
+                                                                                                                                                                     (map list
+                                                                                                                                                                          lexical-new-id-2427
+                                                                                                                                                                          lexical-old-id-2428)
+                                                                                                                                                                     lexical-other-id-2436)
+                                                                                                                                                                    (cons lexical-d-2434
+                                                                                                                                                                          (map (lambda (lexical-tmp-2441
+                                                                                                                                                                                        lexical-tmp-2440)
+                                                                                                                                                                                 (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
+                                                                                                                                                                                              call-or-value
+                                                                                                                                                                                              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?
+                                                                                                                                                                                              tmp-wrap
+                                                                                                                                                                                              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-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
+                                                                                                                                                                                              update-import-binding!
+                                                                                                                                                                                              get-import-binding
+                                                                                                                                                                                              read-only-binding?
+                                                                                                                                                                                              put-global-definition-hook
+                                                                                                                                                                                              get-global-definition-hook
+                                                                                                                                                                                              put-cte-hook
+                                                                                                                                                                                              error-hook
+                                                                                                                                                                                              define-top-level-value-hook
+                                                                                                                                                                                              local-eval-hook
+                                                                                                                                                                                              top-level-eval-hook
+                                                                                                                                                                                              annotation?
+                                                                                                                                                                                              fx>=
+                                                                                                                                                                                              fx<=
+                                                                                                                                                                                              fx>
+                                                                                                                                                                                              fx<
+                                                                                                                                                                                              fx=
+                                                                                                                                                                                              fx-
+                                                                                                                                                                                              fx+
+                                                                                                                                                                                              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)
+                                                                                                                                                                                              (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)
+                                                                                                                                                                                              (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"
+                                                                                                                                                                                              "i"
+                                                                                                                                                                                              "i"
+                                                                                                                                                                                              "i"
+                                                                                                                                                                                              "i"
+                                                                                                                                                                                              "i"
+                                                                                                                                                                                              "i"
+                                                                                                                                                                                              "i"
+                                                                                                                                                                                              "i"
+                                                                                                                                                                                              "i"))
+                                                                                                                                                                                           #(top-ribcage
+                                                                                                                                                                                             *top*
+                                                                                                                                                                                             #t)))
+                                                                                                                                                                                       lexical-tmp-2440
+                                                                                                                                                                                       lexical-tmp-2441))
+                                                                                                                                                                               lexical-old-id-2428
+                                                                                                                                                                               lexical-new-id-2427))))))
+                                                                                                                                            (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
+                                                                                                                                                         call-or-value
+                                                                                                                                                         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?
+                                                                                                                                                         tmp-wrap
+                                                                                                                                                         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-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
+                                                                                                                                                         update-import-binding!
+                                                                                                                                                         get-import-binding
+                                                                                                                                                         read-only-binding?
+                                                                                                                                                         put-global-definition-hook
+                                                                                                                                                         get-global-definition-hook
+                                                                                                                                                         put-cte-hook
+                                                                                                                                                         error-hook
+                                                                                                                                                         define-top-level-value-hook
+                                                                                                                                                         local-eval-hook
+                                                                                                                                                         top-level-eval-hook
+                                                                                                                                                         annotation?
+                                                                                                                                                         fx>=
+                                                                                                                                                         fx<=
+                                                                                                                                                         fx>
+                                                                                                                                                         fx<
+                                                                                                                                                         fx=
+                                                                                                                                                         fx-
+                                                                                                                                                         fx+
+                                                                                                                                                         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)
+                                                                                                                                                         (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)
+                                                                                                                                                         (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"
+                                                                                                                                                         "i"
+                                                                                                                                                         "i"
+                                                                                                                                                         "i"
+                                                                                                                                                         "i"
+                                                                                                                                                         "i"
+                                                                                                                                                         "i"
+                                                                                                                                                         "i"
+                                                                                                                                                         "i"
+                                                                                                                                                         "i"))
+                                                                                                                                                      #(top-ribcage
+                                                                                                                                                        *top*
+                                                                                                                                                        #t)))
+                                                                                                                                                  lexical-orig-2305
+                                                                                                                                                  lexical-import-only?-2306
+                                                                                                                                                  lexical-tmid-2435))
+                                                                                                                                      (if lexical-exports?-2302
+                                                                                                                                          (append
+                                                                                                                                           lexical-new-id-2427
+                                                                                                                                           lexical-other-id-2436)
+                                                                                                                                          '#f)))
+                                                                                                                                   lexical-tmp-2433)
+                                                                                                                            (syntax-error
+                                                                                                                             lexical-tmp-2432)))
+                                                                                                                      ($syntax-dispatch
+                                                                                                                       lexical-tmp-2432
+                                                                                                                       '(any any
+                                                                                                                             each-any))))
+                                                                                                                   (list lexical-d-2430
+                                                                                                                         (lexical-gen-mid-2284
+                                                                                                                          lexical-mid-2429)
+                                                                                                                         lexical-exports-2431)))))
+                                                                                                             lexical-tmp-2420)
+                                                                                                      ((lambda (lexical-tmp-2444)
+                                                                                                         (if (if lexical-tmp-2444
+                                                                                                                 (apply (lambda (lexical-mid-2445)
+                                                                                                                          (identifier?
+                                                                                                                           lexical-mid-2445))
+                                                                                                                        lexical-tmp-2444)
+                                                                                                                 '#f)
+                                                                                                             (apply (lambda (lexical-mid-2446)
+                                                                                                                      (values
+                                                                                                                       lexical-mid-2446
+                                                                                                                       (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
+                                                                                                                                    call-or-value
+                                                                                                                                    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?
+                                                                                                                                    tmp-wrap
+                                                                                                                                    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-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
+                                                                                                                                    update-import-binding!
+                                                                                                                                    get-import-binding
+                                                                                                                                    read-only-binding?
+                                                                                                                                    put-global-definition-hook
+                                                                                                                                    get-global-definition-hook
+                                                                                                                                    put-cte-hook
+                                                                                                                                    error-hook
+                                                                                                                                    define-top-level-value-hook
+                                                                                                                                    local-eval-hook
+                                                                                                                                    top-level-eval-hook
+                                                                                                                                    annotation?
+                                                                                                                                    fx>=
+                                                                                                                                    fx<=
+                                                                                                                                    fx>
+                                                                                                                                    fx<
+                                                                                                                                    fx=
+                                                                                                                                    fx-
+                                                                                                                                    fx+
+                                                                                                                                    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)
+                                                                                                                                    (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)
+                                                                                                                                    (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"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"
+                                                                                                                                    "i"))
+                                                                                                                                 #(top-ribcage
+                                                                                                                                   *top*
+                                                                                                                                   #t)))
+                                                                                                                             lexical-orig-2305
+                                                                                                                             lexical-import-only?-2306
+                                                                                                                             lexical-mid-2446)
+                                                                                                                       (if lexical-exports?-2302
+                                                                                                                           (lexical-$module-exports-2267
+                                                                                                                            lexical-mid-2446
+                                                                                                                            lexical-r-2280)
+                                                                                                                           '#f)))
+                                                                                                                    lexical-tmp-2444)
+                                                                                                             ((lambda (lexical-tmp-2447)
+                                                                                                                (if (if lexical-tmp-2447
+                                                                                                                        (apply (lambda (lexical-mid-2448)
+                                                                                                                                 (identifier?
+                                                                                                                                  lexical-mid-2448))
+                                                                                                                               lexical-tmp-2447)
+                                                                                                                        '#f)
+                                                                                                                    (apply (lambda (lexical-mid-2449)
+                                                                                                                             (values
+                                                                                                                              lexical-mid-2449
+                                                                                                                              (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
+                                                                                                                                           call-or-value
+                                                                                                                                           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?
+                                                                                                                                           tmp-wrap
+                                                                                                                                           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-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
+                                                                                                                                           update-import-binding!
+                                                                                                                                           get-import-binding
+                                                                                                                                           read-only-binding?
+                                                                                                                                           put-global-definition-hook
+                                                                                                                                           get-global-definition-hook
+                                                                                                                                           put-cte-hook
+                                                                                                                                           error-hook
+                                                                                                                                           define-top-level-value-hook
+                                                                                                                                           local-eval-hook
+                                                                                                                                           top-level-eval-hook
+                                                                                                                                           annotation?
+                                                                                                                                           fx>=
+                                                                                                                                           fx<=
+                                                                                                                                           fx>
+                                                                                                                                           fx<
+                                                                                                                                           fx=
+                                                                                                                                           fx-
+                                                                                                                                           fx+
+                                                                                                                                           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)
+                                                                                                                                           (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)
+                                                                                                                                           (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"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"
+                                                                                                                                           "i"))
+                                                                                                                                        #(top-ribcage
+                                                                                                                                          *top*
+                                                                                                                                          #t)))
+                                                                                                                                    lexical-orig-2305
+                                                                                                                                    lexical-import-only?-2306
+                                                                                                                                    lexical-mid-2449)
+                                                                                                                              (if lexical-exports?-2302
+                                                                                                                                  (lexical-$module-exports-2267
+                                                                                                                                   lexical-mid-2449
+                                                                                                                                   lexical-r-2280)
+                                                                                                                                  '#f)))
+                                                                                                                           lexical-tmp-2447)
+                                                                                                                    ((lambda (lexical-_-2450)
+                                                                                                                       (syntax-error
+                                                                                                                        lexical-m-2301
+                                                                                                                        '"invalid module specifier"))
+                                                                                                                     lexical-tmp-2307)))
+                                                                                                              ($syntax-dispatch
+                                                                                                               lexical-tmp-2307
+                                                                                                               '(any)))))
+                                                                                                       (list lexical-tmp-2307))))
+                                                                                                ($syntax-dispatch
+                                                                                                 lexical-tmp-2307
+                                                                                                 '(#(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
+                                                                                                           call-or-value
+                                                                                                           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?
+                                                                                                           tmp-wrap
+                                                                                                           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-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
+                                                                                                           update-import-binding!
+                                                                                                           get-import-binding
+                                                                                                           read-only-binding?
+                                                                                                           put-global-definition-hook
+                                                                                                           get-global-definition-hook
+                                                                                                           put-cte-hook
+                                                                                                           error-hook
+                                                                                                           define-top-level-value-hook
+                                                                                                           local-eval-hook
+                                                                                                           top-level-eval-hook
+                                                                                                           annotation?
+                                                                                                           fx>=
+                                                                                                           fx<=
+                                                                                                           fx>
+                                                                                                           fx<
+                                                                                                           fx=
+                                                                                                           fx-
+                                                                                                           fx+
+                                                                                                           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)
+                                                                                                           (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)
+                                                                                                           (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"
+                                                                                                           "i"
+                                                                                                           "i"
+                                                                                                           "i"
+                                                                                                           "i"
+                                                                                                           "i"
+                                                                                                           "i"
+                                                                                                           "i"
+                                                                                                           "i"
+                                                                                                           "i"))
+                                                                                                        #(top-ribcage
+                                                                                                          *top*
+                                                                                                          #t))))
+                                                                                                   any
+                                                                                                   .
+                                                                                                   #(each (any any)))))))
+                                                                                         ($syntax-dispatch
+                                                                                          lexical-tmp-2307
+                                                                                          '(#(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
+                                                                                                    call-or-value
+                                                                                                    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?
+                                                                                                    tmp-wrap
+                                                                                                    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-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
+                                                                                                    update-import-binding!
+                                                                                                    get-import-binding
+                                                                                                    read-only-binding?
+                                                                                                    put-global-definition-hook
+                                                                                                    get-global-definition-hook
+                                                                                                    put-cte-hook
+                                                                                                    error-hook
+                                                                                                    define-top-level-value-hook
+                                                                                                    local-eval-hook
+                                                                                                    top-level-eval-hook
+                                                                                                    annotation?
+                                                                                                    fx>=
+                                                                                                    fx<=
+                                                                                                    fx>
+                                                                                                    fx<
+                                                                                                    fx=
+                                                                                                    fx-
+                                                                                                    fx+
+                                                                                                    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)
+                                                                                                    (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)
+                                                                                                    (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"
+                                                                                                    "i"
+                                                                                                    "i"
+                                                                                                    "i"
+                                                                                                    "i"
+                                                                                                    "i"
+                                                                                                    "i"
+                                                                                                    "i"
+                                                                                                    "i"
+                                                                                                    "i"))
+                                                                                                 #(top-ribcage
+                                                                                                   *top*
+                                                                                                   #t))))
+                                                                                            any
+                                                                                            .
+                                                                                            #(each (any any)))))))
+                                                                                  ($syntax-dispatch
+                                                                                   lexical-tmp-2307
+                                                                                   '(#(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
+                                                                                             call-or-value
+                                                                                             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?
+                                                                                             tmp-wrap
+                                                                                             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-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
+                                                                                             update-import-binding!
+                                                                                             get-import-binding
+                                                                                             read-only-binding?
+                                                                                             put-global-definition-hook
+                                                                                             get-global-definition-hook
+                                                                                             put-cte-hook
+                                                                                             error-hook
+                                                                                             define-top-level-value-hook
+                                                                                             local-eval-hook
+                                                                                             top-level-eval-hook
+                                                                                             annotation?
+                                                                                             fx>=
+                                                                                             fx<=
+                                                                                             fx>
+                                                                                             fx<
+                                                                                             fx=
+                                                                                             fx-
+                                                                                             fx+
+                                                                                             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)
+                                                                                             (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)
+                                                                                             (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"
+                                                                                             "i"
+                                                                                             "i"
+                                                                                             "i"
+                                                                                             "i"
+                                                                                             "i"
+                                                                                             "i"
+                                                                                             "i"
+                                                                                             "i"
+                                                                                             "i"))
+                                                                                          #(top-ribcage
+                                                                                            *top*
+                                                                                            #t))))
+                                                                                     any
+                                                                                     any)))))
+                                                                           ($syntax-dispatch
+                                                                            lexical-tmp-2307
+                                                                            '(#(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
+                                                                                      call-or-value
+                                                                                      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?
+                                                                                      tmp-wrap
+                                                                                      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-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
+                                                                                      update-import-binding!
+                                                                                      get-import-binding
+                                                                                      read-only-binding?
+                                                                                      put-global-definition-hook
+                                                                                      get-global-definition-hook
+                                                                                      put-cte-hook
+                                                                                      error-hook
+                                                                                      define-top-level-value-hook
+                                                                                      local-eval-hook
+                                                                                      top-level-eval-hook
+                                                                                      annotation?
+                                                                                      fx>=
+                                                                                      fx<=
+                                                                                      fx>
+                                                                                      fx<
+                                                                                      fx=
+                                                                                      fx-
+                                                                                      fx+
+                                                                                      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)
+                                                                                      (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)
+                                                                                      (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"
+                                                                                      "i"
+                                                                                      "i"
+                                                                                      "i"
+                                                                                      "i"
+                                                                                      "i"
+                                                                                      "i"
+                                                                                      "i"
+                                                                                      "i"
+                                                                                      "i"))
+                                                                                   #(top-ribcage
+                                                                                     *top*
+                                                                                     #t))))
+                                                                              any
+                                                                              any)))))
+                                                                    ($syntax-dispatch
+                                                                     lexical-tmp-2307
+                                                                     '(#(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
+                                                                               call-or-value
+                                                                               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?
+                                                                               tmp-wrap
+                                                                               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-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
+                                                                               update-import-binding!
+                                                                               get-import-binding
+                                                                               read-only-binding?
+                                                                               put-global-definition-hook
+                                                                               get-global-definition-hook
+                                                                               put-cte-hook
+                                                                               error-hook
+                                                                               define-top-level-value-hook
+                                                                               local-eval-hook
+                                                                               top-level-eval-hook
+                                                                               annotation?
+                                                                               fx>=
+                                                                               fx<=
+                                                                               fx>
+                                                                               fx<
+                                                                               fx=
+                                                                               fx-
+                                                                               fx+
+                                                                               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)
+                                                                               (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)
+                                                                               (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"
+                                                                               "i"
+                                                                               "i"
+                                                                               "i"
+                                                                               "i"
+                                                                               "i"
+                                                                               "i"
+                                                                               "i"
+                                                                               "i"
+                                                                               "i"))
+                                                                            #(top-ribcage
+                                                                              *top*
+                                                                              #t))))
+                                                                       any
+                                                                       .
+                                                                       each-any)))))
+                                                             ($syntax-dispatch
+                                                              lexical-tmp-2307
+                                                              '(#(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
+                                                                        call-or-value
+                                                                        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?
+                                                                        tmp-wrap
+                                                                        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-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
+                                                                        update-import-binding!
+                                                                        get-import-binding
+                                                                        read-only-binding?
+                                                                        put-global-definition-hook
+                                                                        get-global-definition-hook
+                                                                        put-cte-hook
+                                                                        error-hook
+                                                                        define-top-level-value-hook
+                                                                        local-eval-hook
+                                                                        top-level-eval-hook
+                                                                        annotation?
+                                                                        fx>=
+                                                                        fx<=
+                                                                        fx>
+                                                                        fx<
+                                                                        fx=
+                                                                        fx-
+                                                                        fx+
+                                                                        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)
+                                                                        (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)
+                                                                        (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"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"))
+                                                                     #(top-ribcage
+                                                                       *top*
+                                                                       #t))))
+                                                                any
+                                                                .
+                                                                each-any))))
+                                                          lexical-m-2301))
+                                                       lexical-tmp-2304)
+                                                (syntax-error lexical-tmp-2303)))
+                                          ($syntax-dispatch
+                                           lexical-tmp-2303
+                                           '(any any))))
+                                       (list lexical-orig-2278
+                                             lexical-import-only?-2279))))
+                                   (lexical-modspec*-2286
+                                    (lambda (lexical-m-2451)
+                                      (call-with-values
+                                       (lambda ()
+                                         (lexical-modspec-2285
+                                          lexical-m-2451
+                                          '#f))
+                                       (lambda (lexical-mid-2452
+                                                lexical-d-2453
+                                                lexical-exports-2454)
+                                         lexical-d-2453)))))
+                           ((lambda (lexical-tmp-2455)
+                              ((lambda (lexical-tmp-2456)
+                                 (if lexical-tmp-2456
+                                     (apply (lambda (lexical-_-2457
+                                                     lexical-m-2458)
+                                              ((lambda (lexical-tmp-2459)
+                                                 ((lambda (lexical-tmp-2460)
+                                                    (if lexical-tmp-2460
+                                                        (apply (lambda (lexical-d-2461)
+                                                                 (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
+                                                                              call-or-value
+                                                                              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?
+                                                                              tmp-wrap
+                                                                              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-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
+                                                                              update-import-binding!
+                                                                              get-import-binding
+                                                                              read-only-binding?
+                                                                              put-global-definition-hook
+                                                                              get-global-definition-hook
+                                                                              put-cte-hook
+                                                                              error-hook
+                                                                              define-top-level-value-hook
+                                                                              local-eval-hook
+                                                                              top-level-eval-hook
+                                                                              annotation?
+                                                                              fx>=
+                                                                              fx<=
+                                                                              fx>
+                                                                              fx<
+                                                                              fx=
+                                                                              fx-
+                                                                              fx+
+                                                                              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)
+                                                                              (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)
+                                                                              (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"
+                                                                              "i"
+                                                                              "i"
+                                                                              "i"
+                                                                              "i"
+                                                                              "i"
+                                                                              "i"
+                                                                              "i"
+                                                                              "i"
+                                                                              "i"))
+                                                                           #(top-ribcage
+                                                                             *top*
+                                                                             #t)))
+                                                                       lexical-d-2461))
+                                                               lexical-tmp-2460)
+                                                        (syntax-error
+                                                         lexical-tmp-2459)))
+                                                  ($syntax-dispatch
+                                                   lexical-tmp-2459
+                                                   'each-any)))
+                                               (map lexical-modspec*-2286
+                                                    lexical-m-2458)))
+                                            lexical-tmp-2456)
+                                     (syntax-error lexical-tmp-2455)))
+                               ($syntax-dispatch
+                                lexical-tmp-2455
+                                '(any . each-any))))
+                            lexical-orig-2278))))))
+            (begin
+              (lexical-put-cte-hook-163
+               '%primitive-import
+               (lambda (lexical-orig-2464)
+                 (lexical-$import-help-2268 lexical-orig-2464 '#f)))
+              (lexical-put-cte-hook-163
+               'import-only
+               (lambda (lexical-orig-2465)
+                 (lexical-$import-help-2268 lexical-orig-2465 '#t)))))))
+       (set! sc-expand
+             (lambda (lexical-x-2466
+                      lexical-env-2467
+                      lexical-ctem-2468
+                      lexical-rtem-2469)
+               ((lambda (lexical-env-2470 lexical-ctem-2471 lexical-rtem-2472)
+                  (if (if (pair? lexical-x-2466)
+                          (equal? (car lexical-x-2466) lexical-noexpand-87)
+                          '#f)
+                      (cadr lexical-x-2466)
+                      (lexical-chi-top*-474
+                       lexical-x-2466
+                       '()
+                       (lexical-env-wrap-415 lexical-env-2470)
+                       lexical-ctem-2471
+                       lexical-rtem-2472
+                       '#f
+                       (lexical-env-top-ribcage-414 lexical-env-2470))))
+                ((lambda (lexical-t-2473)
+                   (if lexical-t-2473 lexical-t-2473 (interaction-environment)))
+                 lexical-env-2467)
+                ((lambda (lexical-t-2474)
+                   (if lexical-t-2474 lexical-t-2474 '(E)))
+                 lexical-ctem-2468)
+                ((lambda (lexical-t-2475)
+                   (if lexical-t-2475 lexical-t-2475 '(E)))
+                 lexical-rtem-2469))))
+       (set! $make-environment
+             (lambda (lexical-token-2476 lexical-mutable?-2477)
+               ((lambda (lexical-top-ribcage-2478)
+                  (lexical-make-env-412
+                   lexical-top-ribcage-2478
+                   (lexical-make-wrap-342
+                    (lexical-wrap-marks-343 '((top)))
+                    (cons lexical-top-ribcage-2478
+                          (lexical-wrap-subst-344 '((top)))))))
+                (lexical-make-top-ribcage-400
+                 lexical-token-2476
+                 lexical-mutable?-2477))))
+       (set! environment?
+             (lambda (lexical-x-2479) (lexical-env?-413 lexical-x-2479)))
+       (set! interaction-environment
+             ((lambda (lexical-e-2480) (lambda () lexical-e-2480))
+              ($make-environment '*top* '#t)))
+       (set! identifier?
+             (lambda (lexical-x-2481)
+               (lexical-nonsymbol-id?-332 lexical-x-2481)))
+       (set! datum->syntax-object
+             (lambda (lexical-id-2482 lexical-datum-2483)
+               (begin
+                 ((lambda (lexical-x-2484)
+                    (if (not (lexical-nonsymbol-id?-332 lexical-x-2484))
+                        (lexical-error-hook-162
+                         'datum->syntax-object
+                         '"invalid argument"
+                         lexical-x-2484)
+                        (void)))
+                  lexical-id-2482)
+                 (lexical-make-syntax-object-89
+                  lexical-datum-2483
+                  (lexical-syntax-object-wrap-92 lexical-id-2482)))))
+       (set! unwrap-syntax
+             (lambda (lexical-stx-2485)
+               ((lambda (lexical-tmp-2486)
+                  ((lambda (lexical-tmp-2487)
+                     (if lexical-tmp-2487
+                         (apply (lambda (lexical-first-2488 lexical-rest-2489)
+                                  (cons lexical-first-2488 lexical-rest-2489))
+                                lexical-tmp-2487)
+                         ((lambda (lexical-tmp-2490)
+                            (if lexical-tmp-2490
+                                (apply (lambda (lexical-x-2491)
+                                         (apply vector lexical-x-2491))
+                                       lexical-tmp-2490)
+                                ((lambda (lexical-_-2493) lexical-stx-2485)
+                                 lexical-tmp-2486)))
+                          ($syntax-dispatch
+                           lexical-tmp-2486
+                           '#(vector each-any)))))
+                   ($syntax-dispatch lexical-tmp-2486 '(any . any))))
+                lexical-stx-2485)))
+       (set! syntax-object->datum
+             (lambda (lexical-x-2494) (lexical-strip-550 lexical-x-2494 '(()))))
+       (set! generate-temporaries
+             ((lambda (lexical-n-2495)
+                (lambda (lexical-ls-2496)
+                  (begin
+                    ((lambda (lexical-x-2497)
+                       (if (not (list? lexical-x-2497))
+                           (lexical-error-hook-162
+                            'generate-temporaries
+                            '"invalid argument"
+                            lexical-x-2497)
+                           (void)))
+                     lexical-ls-2496)
+                    (map (lambda (lexical-x-2498)
+                           (begin
+                             (set! lexical-n-2495 (+ lexical-n-2495 '1))
+                             (lexical-wrap-470
+                              (string->symbol
+                               (string-append
+                                '"t"
+                                (number->string lexical-n-2495)))
+                              '((tmp)))))
+                         lexical-ls-2496))))
+              '0))
+       (set! free-identifier=?
+             (lambda (lexical-x-2499 lexical-y-2500)
+               (begin
+                 ((lambda (lexical-x-2501)
+                    (if (not (lexical-nonsymbol-id?-332 lexical-x-2501))
+                        (lexical-error-hook-162
+                         'free-identifier=?
+                         '"invalid argument"
+                         lexical-x-2501)
+                        (void)))
+                  lexical-x-2499)
+                 ((lambda (lexical-x-2502)
+                    (if (not (lexical-nonsymbol-id?-332 lexical-x-2502))
+                        (lexical-error-hook-162
+                         'free-identifier=?
+                         '"invalid argument"
+                         lexical-x-2502)
+                        (void)))
+                  lexical-y-2500)
+                 (lexical-free-id=?-462 lexical-x-2499 lexical-y-2500))))
+       (set! bound-identifier=?
+             (lambda (lexical-x-2503 lexical-y-2504)
+               (begin
+                 ((lambda (lexical-x-2505)
+                    (if (not (lexical-nonsymbol-id?-332 lexical-x-2505))
+                        (lexical-error-hook-162
+                         'bound-identifier=?
+                         '"invalid argument"
+                         lexical-x-2505)
+                        (void)))
+                  lexical-x-2503)
+                 ((lambda (lexical-x-2506)
+                    (if (not (lexical-nonsymbol-id?-332 lexical-x-2506))
+                        (lexical-error-hook-162
+                         'bound-identifier=?
+                         '"invalid argument"
+                         lexical-x-2506)
+                        (void)))
+                  lexical-y-2504)
+                 (lexical-bound-id=?-465 lexical-x-2503 lexical-y-2504))))
+       (set! literal-identifier=?
+             (lambda (lexical-x-2507 lexical-y-2508)
+               (begin
+                 ((lambda (lexical-x-2509)
+                    (if (not (lexical-nonsymbol-id?-332 lexical-x-2509))
+                        (lexical-error-hook-162
+                         'literal-identifier=?
+                         '"invalid argument"
+                         lexical-x-2509)
+                        (void)))
+                  lexical-x-2507)
+                 ((lambda (lexical-x-2510)
+                    (if (not (lexical-nonsymbol-id?-332 lexical-x-2510))
+                        (lexical-error-hook-162
+                         'literal-identifier=?
+                         '"invalid argument"
+                         lexical-x-2510)
+                        (void)))
+                  lexical-y-2508)
+                 (lexical-literal-id=?-463 lexical-x-2507 lexical-y-2508))))
+       (set! syntax-error
+             (lambda (lexical-object-2512 . lexical-messages-2511)
+               (begin
+                 (for-each
+                  (lambda (lexical-x-2513)
+                    ((lambda (lexical-x-2514)
+                       (if (not (string? lexical-x-2514))
+                           (lexical-error-hook-162
+                            'syntax-error
+                            '"invalid argument"
+                            lexical-x-2514)
+                           (void)))
+                     lexical-x-2513))
+                  lexical-messages-2511)
+                 ((lambda (lexical-message-2515)
+                    (lexical-error-hook-162
+                     '#f
+                     lexical-message-2515
+                     (lexical-strip-550 lexical-object-2512 '(()))))
+                  (if (null? lexical-messages-2511)
+                      '"invalid syntax"
+                      (apply string-append lexical-messages-2511))))))
+       ((lambda ()
+          (letrec* ((lexical-match-each-2516
+                     (lambda (lexical-e-2523 lexical-p-2524 lexical-w-2525)
+                       (if (lexical-annotation?-158 lexical-e-2523)
+                           (lexical-match-each-2516
+                            (annotation-expression lexical-e-2523)
+                            lexical-p-2524
+                            lexical-w-2525)
+                           (if (pair? lexical-e-2523)
+                               ((lambda (lexical-first-2526)
+                                  (if lexical-first-2526
+                                      ((lambda (lexical-rest-2527)
+                                         (if lexical-rest-2527
+                                             (cons lexical-first-2526
+                                                   lexical-rest-2527)
+                                             '#f))
+                                       (lexical-match-each-2516
+                                        (cdr lexical-e-2523)
+                                        lexical-p-2524
+                                        lexical-w-2525))
+                                      '#f))
+                                (lexical-match-2522
+                                 (car lexical-e-2523)
+                                 lexical-p-2524
+                                 lexical-w-2525
+                                 '()))
+                               (if (null? lexical-e-2523)
+                                   '()
+                                   (if (lexical-syntax-object?-90
+                                        lexical-e-2523)
+                                       (lexical-match-each-2516
+                                        (lexical-syntax-object-expression-91
+                                         lexical-e-2523)
+                                        lexical-p-2524
+                                        (lexical-join-wraps-449
+                                         lexical-w-2525
+                                         (lexical-syntax-object-wrap-92
+                                          lexical-e-2523)))
+                                       '#f))))))
+                    (lexical-match-each+-2517
+                     (lambda (lexical-e-2528
+                              lexical-x-pat-2529
+                              lexical-y-pat-2530
+                              lexical-z-pat-2531
+                              lexical-w-2532
+                              lexical-r-2533)
+                       ((letrec ((lexical-f-2534
+                                  (lambda (lexical-e-2535 lexical-w-2536)
+                                    (if (pair? lexical-e-2535)
+                                        (call-with-values
+                                         (lambda ()
+                                           (lexical-f-2534
+                                            (cdr lexical-e-2535)
+                                            lexical-w-2536))
+                                         (lambda (lexical-xr*-2537
+                                                  lexical-y-pat-2538
+                                                  lexical-r-2539)
+                                           (if lexical-r-2539
+                                               (if (null? lexical-y-pat-2538)
+                                                   ((lambda (lexical-xr-2540)
+                                                      (if lexical-xr-2540
+                                                          (values
+                                                           (cons lexical-xr-2540
+                                                                 lexical-xr*-2537)
+                                                           lexical-y-pat-2538
+                                                           lexical-r-2539)
+                                                          (values '#f '#f '#f)))
+                                                    (lexical-match-2522
+                                                     (car lexical-e-2535)
+                                                     lexical-x-pat-2529
+                                                     lexical-w-2536
+                                                     '()))
+                                                   (values
+                                                    '()
+                                                    (cdr lexical-y-pat-2538)
+                                                    (lexical-match-2522
+                                                     (car lexical-e-2535)
+                                                     (car lexical-y-pat-2538)
+                                                     lexical-w-2536
+                                                     lexical-r-2539)))
+                                               (values '#f '#f '#f))))
+                                        (if (lexical-annotation?-158
+                                             lexical-e-2535)
+                                            (lexical-f-2534
+                                             (annotation-expression
+                                              lexical-e-2535)
+                                             lexical-w-2536)
+                                            (if (lexical-syntax-object?-90
+                                                 lexical-e-2535)
+                                                (lexical-f-2534
+                                                 (lexical-syntax-object-expression-91
+                                                  lexical-e-2535)
+                                                 (lexical-join-wraps-449
+                                                  lexical-w-2536
+                                                  (lexical-syntax-object-wrap-92
+                                                   lexical-e-2535)))
+                                                (values
+                                                 '()
+                                                 lexical-y-pat-2530
+                                                 (lexical-match-2522
+                                                  lexical-e-2535
+                                                  lexical-z-pat-2531
+                                                  lexical-w-2536
+                                                  lexical-r-2533))))))))
+                          lexical-f-2534)
+                        lexical-e-2528
+                        lexical-w-2532)))
+                    (lexical-match-each-any-2518
+                     (lambda (lexical-e-2541 lexical-w-2542)
+                       (if (lexical-annotation?-158 lexical-e-2541)
+                           (lexical-match-each-any-2518
+                            (annotation-expression lexical-e-2541)
+                            lexical-w-2542)
+                           (if (pair? lexical-e-2541)
+                               ((lambda (lexical-l-2543)
+                                  (if lexical-l-2543
+                                      (cons (lexical-wrap-470
+                                             (car lexical-e-2541)
+                                             lexical-w-2542)
+                                            lexical-l-2543)
+                                      '#f))
+                                (lexical-match-each-any-2518
+                                 (cdr lexical-e-2541)
+                                 lexical-w-2542))
+                               (if (null? lexical-e-2541)
+                                   '()
+                                   (if (lexical-syntax-object?-90
+                                        lexical-e-2541)
+                                       (lexical-match-each-any-2518
+                                        (lexical-syntax-object-expression-91
+                                         lexical-e-2541)
+                                        (lexical-join-wraps-449
+                                         lexical-w-2542
+                                         (lexical-syntax-object-wrap-92
+                                          lexical-e-2541)))
+                                       '#f))))))
+                    (lexical-match-empty-2519
+                     (lambda (lexical-p-2544 lexical-r-2545)
+                       (if (null? lexical-p-2544)
+                           lexical-r-2545
+                           (if (eq? lexical-p-2544 'any)
+                               (cons '() lexical-r-2545)
+                               (if (pair? lexical-p-2544)
+                                   (lexical-match-empty-2519
+                                    (car lexical-p-2544)
+                                    (lexical-match-empty-2519
+                                     (cdr lexical-p-2544)
+                                     lexical-r-2545))
+                                   (if (eq? lexical-p-2544 'each-any)
+                                       (cons '() lexical-r-2545)
+                                       ((lambda (lexical-t-2546)
+                                          (if (memv lexical-t-2546 '(each))
+                                              (lexical-match-empty-2519
+                                               (vector-ref lexical-p-2544 '1)
+                                               lexical-r-2545)
+                                              (if (memv lexical-t-2546
+                                                        '(each+))
+                                                  (lexical-match-empty-2519
+                                                   (vector-ref
+                                                    lexical-p-2544
+                                                    '1)
+                                                   (lexical-match-empty-2519
+                                                    (reverse
+                                                     (vector-ref
+                                                      lexical-p-2544
+                                                      '2))
+                                                    (lexical-match-empty-2519
+                                                     (vector-ref
+                                                      lexical-p-2544
+                                                      '3)
+                                                     lexical-r-2545)))
+                                                  (if (memv lexical-t-2546
+                                                            '(free-id atom))
+                                                      lexical-r-2545
+                                                      (if (memv lexical-t-2546
+                                                                '(vector))
+                                                          (lexical-match-empty-2519
+                                                           (vector-ref
+                                                            lexical-p-2544
+                                                            '1)
+                                                           lexical-r-2545)
+                                                          (void))))))
+                                        (vector-ref lexical-p-2544 '0))))))))
+                    (lexical-combine-2520
+                     (lambda (lexical-r*-2547 lexical-r-2548)
+                       (if (null? (car lexical-r*-2547))
+                           lexical-r-2548
+                           (cons (map car lexical-r*-2547)
+                                 (lexical-combine-2520
+                                  (map cdr lexical-r*-2547)
+                                  lexical-r-2548)))))
+                    (lexical-match*-2521
+                     (lambda (lexical-e-2549
+                              lexical-p-2550
+                              lexical-w-2551
+                              lexical-r-2552)
+                       (if (null? lexical-p-2550)
+                           (if (null? lexical-e-2549) lexical-r-2552 '#f)
+                           (if (pair? lexical-p-2550)
+                               (if (pair? lexical-e-2549)
+                                   (lexical-match-2522
+                                    (car lexical-e-2549)
+                                    (car lexical-p-2550)
+                                    lexical-w-2551
+                                    (lexical-match-2522
+                                     (cdr lexical-e-2549)
+                                     (cdr lexical-p-2550)
+                                     lexical-w-2551
+                                     lexical-r-2552))
+                                   '#f)
+                               (if (eq? lexical-p-2550 'each-any)
+                                   ((lambda (lexical-l-2553)
+                                      (if lexical-l-2553
+                                          (cons lexical-l-2553 lexical-r-2552)
+                                          '#f))
+                                    (lexical-match-each-any-2518
+                                     lexical-e-2549
+                                     lexical-w-2551))
+                                   ((lambda (lexical-t-2554)
+                                      (if (memv lexical-t-2554 '(each))
+                                          (if (null? lexical-e-2549)
+                                              (lexical-match-empty-2519
+                                               (vector-ref lexical-p-2550 '1)
+                                               lexical-r-2552)
+                                              ((lambda (lexical-r*-2555)
+                                                 (if lexical-r*-2555
+                                                     (lexical-combine-2520
+                                                      lexical-r*-2555
+                                                      lexical-r-2552)
+                                                     '#f))
+                                               (lexical-match-each-2516
+                                                lexical-e-2549
+                                                (vector-ref lexical-p-2550 '1)
+                                                lexical-w-2551)))
+                                          (if (memv lexical-t-2554 '(free-id))
+                                              (if (lexical-id?-333
+                                                   lexical-e-2549)
+                                                  (if (lexical-literal-id=?-463
+                                                       (lexical-wrap-470
+                                                        lexical-e-2549
+                                                        lexical-w-2551)
+                                                       (vector-ref
+                                                        lexical-p-2550
+                                                        '1))
+                                                      lexical-r-2552
+                                                      '#f)
+                                                  '#f)
+                                              (if (memv lexical-t-2554
+                                                        '(each+))
+                                                  (call-with-values
+                                                   (lambda ()
+                                                     (lexical-match-each+-2517
+                                                      lexical-e-2549
+                                                      (vector-ref
+                                                       lexical-p-2550
+                                                       '1)
+                                                      (vector-ref
+                                                       lexical-p-2550
+                                                       '2)
+                                                      (vector-ref
+                                                       lexical-p-2550
+                                                       '3)
+                                                      lexical-w-2551
+                                                      lexical-r-2552))
+                                                   (lambda (lexical-xr*-2556
+                                                            lexical-y-pat-2557
+                                                            lexical-r-2558)
+                                                     (if lexical-r-2558
+                                                         (if (null? lexical-y-pat-2557)
+                                                             (if (null? lexical-xr*-2556)
+                                                                 (lexical-match-empty-2519
+                                                                  (vector-ref
+                                                                   lexical-p-2550
+                                                                   '1)
+                                                                  lexical-r-2558)
+                                                                 (lexical-combine-2520
+                                                                  lexical-xr*-2556
+                                                                  lexical-r-2558))
+                                                             '#f)
+                                                         '#f)))
+                                                  (if (memv lexical-t-2554
+                                                            '(atom))
+                                                      (if (equal?
+                                                           (vector-ref
+                                                            lexical-p-2550
+                                                            '1)
+                                                           (lexical-strip-550
+                                                            lexical-e-2549
+                                                            lexical-w-2551))
+                                                          lexical-r-2552
+                                                          '#f)
+                                                      (if (memv lexical-t-2554
+                                                                '(vector))
+                                                          (if (vector?
+                                                               lexical-e-2549)
+                                                              (lexical-match-2522
+                                                               (vector->list
+                                                                lexical-e-2549)
+                                                               (vector-ref
+                                                                lexical-p-2550
+                                                                '1)
+                                                               lexical-w-2551
+                                                               lexical-r-2552)
+                                                              '#f)
+                                                          (void)))))))
+                                    (vector-ref lexical-p-2550 '0)))))))
+                    (lexical-match-2522
+                     (lambda (lexical-e-2559
+                              lexical-p-2560
+                              lexical-w-2561
+                              lexical-r-2562)
+                       (if (not lexical-r-2562)
+                           '#f
+                           (if (eq? lexical-p-2560 'any)
+                               (cons (lexical-wrap-470
+                                      lexical-e-2559
+                                      lexical-w-2561)
+                                     lexical-r-2562)
+                               (if (lexical-syntax-object?-90 lexical-e-2559)
+                                   (lexical-match*-2521
+                                    ((lambda (lexical-e-2563)
+                                       (if (lexical-annotation?-158
+                                            lexical-e-2563)
+                                           (annotation-expression
+                                            lexical-e-2563)
+                                           lexical-e-2563))
+                                     (lexical-syntax-object-expression-91
+                                      lexical-e-2559))
+                                    lexical-p-2560
+                                    (lexical-join-wraps-449
+                                     lexical-w-2561
+                                     (lexical-syntax-object-wrap-92
+                                      lexical-e-2559))
+                                    lexical-r-2562)
+                                   (lexical-match*-2521
+                                    ((lambda (lexical-e-2564)
+                                       (if (lexical-annotation?-158
+                                            lexical-e-2564)
+                                           (annotation-expression
+                                            lexical-e-2564)
+                                           lexical-e-2564))
+                                     lexical-e-2559)
+                                    lexical-p-2560
+                                    lexical-w-2561
+                                    lexical-r-2562)))))))
+            (set! $syntax-dispatch
+                  (lambda (lexical-e-2565 lexical-p-2566)
+                    (if (eq? lexical-p-2566 'any)
+                        (list lexical-e-2565)
+                        (if (lexical-syntax-object?-90 lexical-e-2565)
+                            (lexical-match*-2521
+                             ((lambda (lexical-e-2567)
+                                (if (lexical-annotation?-158 lexical-e-2567)
+                                    (annotation-expression lexical-e-2567)
+                                    lexical-e-2567))
+                              (lexical-syntax-object-expression-91
+                               lexical-e-2565))
+                             lexical-p-2566
+                             (lexical-syntax-object-wrap-92 lexical-e-2565)
+                             '())
+                            (lexical-match*-2521
+                             ((lambda (lexical-e-2568)
+                                (if (lexical-annotation?-158 lexical-e-2568)
+                                    (annotation-expression lexical-e-2568)
+                                    lexical-e-2568))
+                              lexical-e-2565)
+                             lexical-p-2566
+                             '(())
+                             '()))))))))))))
+
+($sc-put-cte
+ '#(syntax-object
+    with-syntax
+    ((top) #(ribcage #(with-syntax) #((top)) #(with-syntax))))
+ (lambda (lexical-x-2569)
+   ((lambda (lexical-tmp-2570)
+      ((lambda (lexical-tmp-2571)
+         (if lexical-tmp-2571
+             (apply (lambda (lexical-_-2572 lexical-e1-2573 lexical-e2-2574)
+                      (cons '#(syntax-object
+                               begin
+                               ((top)
+                                #(ribcage
+                                  #(_ e1 e2)
+                                  #((top) (top) (top))
+                                  #("i" "i" "i"))
+                                #(ribcage () () ())
+                                #(ribcage #(x) #((top)) #("i"))
+                                #(top-ribcage *top* #t)))
+                            (cons lexical-e1-2573 lexical-e2-2574)))
+                    lexical-tmp-2571)
+             ((lambda (lexical-tmp-2576)
+                (if lexical-tmp-2576
+                    (apply (lambda (lexical-_-2577
+                                    lexical-out-2578
+                                    lexical-in-2579
+                                    lexical-e1-2580
+                                    lexical-e2-2581)
+                             (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)))
+                                   lexical-in-2579
+                                   '()
+                                   (list lexical-out-2578
+                                         (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 lexical-e1-2580
+                                                     lexical-e2-2581)))))
+                           lexical-tmp-2576)
+                    ((lambda (lexical-tmp-2583)
+                       (if lexical-tmp-2583
+                           (apply (lambda (lexical-_-2584
+                                           lexical-out-2585
+                                           lexical-in-2586
+                                           lexical-e1-2587
+                                           lexical-e2-2588)
+                                    (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)))
+                                                lexical-in-2586)
+                                          '()
+                                          (list lexical-out-2585
+                                                (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 lexical-e1-2587
+                                                            lexical-e2-2588)))))
+                                  lexical-tmp-2583)
+                           (syntax-error lexical-tmp-2570)))
+                     ($syntax-dispatch
+                      lexical-tmp-2570
+                      '(any #(each (any any)) any . each-any)))))
+              ($syntax-dispatch
+               lexical-tmp-2570
+               '(any ((any any)) any . each-any)))))
+       ($syntax-dispatch lexical-tmp-2570 '(any () any . each-any))))
+    lexical-x-2569))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object
+    with-implicit
+    ((top) #(ribcage #(with-implicit) #((top)) #(with-implicit))))
+ (lambda (lexical-x-2592)
+   ((lambda (lexical-tmp-2593)
+      ((lambda (lexical-tmp-2594)
+         (if (if lexical-tmp-2594
+                 (apply (lambda (lexical-dummy-2595
+                                 lexical-tid-2596
+                                 lexical-id-2597
+                                 lexical-e1-2598
+                                 lexical-e2-2599)
+                          (andmap
+                           identifier?
+                           (cons lexical-tid-2596 lexical-id-2597)))
+                        lexical-tmp-2594)
+                 '#f)
+             (apply (lambda (lexical-dummy-2601
+                             lexical-tid-2602
+                             lexical-id-2603
+                             lexical-e1-2604
+                             lexical-e2-2605)
+                      (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)))
+                                              lexical-tid-2602))
+                                  (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)))
+                                                    lexical-tid-2602)
+                                              '#(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 (lambda (lexical-tmp-2606)
+                                               (list lexical-tmp-2606
+                                                     (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)))
+                                                                 lexical-tid-2602)
+                                                           (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)))
+                                                                 lexical-tmp-2606))))
+                                             lexical-id-2603)
+                                        (cons lexical-e1-2604 lexical-e2-2605)))))
+                    lexical-tmp-2594)
+             (syntax-error lexical-tmp-2593)))
+       ($syntax-dispatch
+        lexical-tmp-2593
+        '(any (any . each-any) any . each-any))))
+    lexical-x-2592))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object datum ((top) #(ribcage #(datum) #((top)) #(datum))))
+ (lambda (lexical-x-2608)
+   ((lambda (lexical-tmp-2609)
+      ((lambda (lexical-tmp-2610)
+         (if lexical-tmp-2610
+             (apply (lambda (lexical-dummy-2611 lexical-x-2612)
+                      (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)))
+                                  lexical-x-2612)))
+                    lexical-tmp-2610)
+             (syntax-error lexical-tmp-2609)))
+       ($syntax-dispatch lexical-tmp-2609 '(any any))))
+    lexical-x-2608))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object
+    syntax-rules
+    ((top) #(ribcage #(syntax-rules) #((top)) #(syntax-rules))))
+ (lambda (lexical-x-2613)
+   (letrec* ((lexical-clause-2614
+              (lambda (lexical-y-2615)
+                ((lambda (lexical-tmp-2616)
+                   ((lambda (lexical-tmp-2617)
+                      (if lexical-tmp-2617
+                          (apply (lambda (lexical-keyword-2618
+                                          lexical-pattern-2619
+                                          lexical-template-2620)
+                                   (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)))
+                                               lexical-pattern-2619)
+                                         (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)))
+                                               lexical-template-2620)))
+                                 lexical-tmp-2617)
+                          ((lambda (lexical-tmp-2621)
+                             (if lexical-tmp-2621
+                                 (apply (lambda (lexical-keyword-2622
+                                                 lexical-pattern-2623
+                                                 lexical-fender-2624
+                                                 lexical-template-2625)
+                                          (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)))
+                                                      lexical-pattern-2623)
+                                                lexical-fender-2624
+                                                (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)))
+                                                      lexical-template-2625)))
+                                        lexical-tmp-2621)
+                                 ((lambda (lexical-_-2626)
+                                    (syntax-error lexical-x-2613))
+                                  lexical-tmp-2616)))
+                           ($syntax-dispatch
+                            lexical-tmp-2616
+                            '((any . any) any any)))))
+                    ($syntax-dispatch lexical-tmp-2616 '((any . any) any))))
+                 lexical-y-2615))))
+     ((lambda (lexical-tmp-2627)
+        ((lambda (lexical-tmp-2628)
+           (if (if lexical-tmp-2628
+                   (apply (lambda (lexical-_-2629
+                                   lexical-k-2630
+                                   lexical-cl-2631)
+                            (andmap identifier? lexical-k-2630))
+                          lexical-tmp-2628)
+                   '#f)
+               (apply (lambda (lexical-_-2633 lexical-k-2634 lexical-cl-2635)
+                        ((lambda (lexical-tmp-2636)
+                           ((lambda (lexical-tmp-2637)
+                              (if lexical-tmp-2637
+                                  (apply (lambda (lexical-cl-2638)
+                                           (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 lexical-k-2634
+                                                                   lexical-cl-2638)))))
+                                         lexical-tmp-2637)
+                                  (syntax-error lexical-tmp-2636)))
+                            ($syntax-dispatch lexical-tmp-2636 'each-any)))
+                         (map lexical-clause-2614 lexical-cl-2635)))
+                      lexical-tmp-2628)
+               (syntax-error lexical-tmp-2627)))
+         ($syntax-dispatch lexical-tmp-2627 '(any each-any . each-any))))
+      lexical-x-2613)))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object or ((top) #(ribcage #(or) #((top)) #(or))))
+ (lambda (lexical-x-2642)
+   ((lambda (lexical-tmp-2643)
+      ((lambda (lexical-tmp-2644)
+         (if lexical-tmp-2644
+             (apply (lambda (lexical-_-2645)
+                      '#(syntax-object
+                         #f
+                         ((top)
+                          #(ribcage #(_) #((top)) #("i"))
+                          #(ribcage () () ())
+                          #(ribcage #(x) #((top)) #("i"))
+                          #(top-ribcage *top* #t))))
+                    lexical-tmp-2644)
+             ((lambda (lexical-tmp-2646)
+                (if lexical-tmp-2646
+                    (apply (lambda (lexical-_-2647 lexical-e-2648)
+                             lexical-e-2648)
+                           lexical-tmp-2646)
+                    ((lambda (lexical-tmp-2649)
+                       (if lexical-tmp-2649
+                           (apply (lambda (lexical-_-2650
+                                           lexical-e1-2651
+                                           lexical-e2-2652
+                                           lexical-e3-2653)
+                                    (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)))
+                                                      lexical-e1-2651))
+                                          (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 lexical-e2-2652
+                                                            lexical-e3-2653)))))
+                                  lexical-tmp-2649)
+                           (syntax-error lexical-tmp-2643)))
+                     ($syntax-dispatch
+                      lexical-tmp-2643
+                      '(any any any . each-any)))))
+              ($syntax-dispatch lexical-tmp-2643 '(any any)))))
+       ($syntax-dispatch lexical-tmp-2643 '(any))))
+    lexical-x-2642))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object and ((top) #(ribcage #(and) #((top)) #(and))))
+ (lambda (lexical-x-2655)
+   ((lambda (lexical-tmp-2656)
+      ((lambda (lexical-tmp-2657)
+         (if lexical-tmp-2657
+             (apply (lambda (lexical-_-2658
+                             lexical-e1-2659
+                             lexical-e2-2660
+                             lexical-e3-2661)
+                      (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 lexical-e1-2659
+                                  (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 lexical-e2-2660
+                                                    lexical-e3-2661))
+                                        '#(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)))))))
+                    lexical-tmp-2657)
+             ((lambda (lexical-tmp-2663)
+                (if lexical-tmp-2663
+                    (apply (lambda (lexical-_-2664 lexical-e-2665)
+                             lexical-e-2665)
+                           lexical-tmp-2663)
+                    ((lambda (lexical-tmp-2666)
+                       (if lexical-tmp-2666
+                           (apply (lambda (lexical-_-2667)
+                                    '#(syntax-object
+                                       #t
+                                       ((top)
+                                        #(ribcage #(_) #((top)) #("i"))
+                                        #(ribcage () () ())
+                                        #(ribcage #(x) #((top)) #("i"))
+                                        #(top-ribcage *top* #t))))
+                                  lexical-tmp-2666)
+                           (syntax-error lexical-tmp-2656)))
+                     ($syntax-dispatch lexical-tmp-2656 '(any)))))
+              ($syntax-dispatch lexical-tmp-2656 '(any any)))))
+       ($syntax-dispatch lexical-tmp-2656 '(any any any . each-any))))
+    lexical-x-2655))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object let ((top) #(ribcage #(let) #((top)) #(let))))
+ (lambda (lexical-x-2668)
+   ((lambda (lexical-tmp-2669)
+      ((lambda (lexical-tmp-2670)
+         (if (if lexical-tmp-2670
+                 (apply (lambda (lexical-_-2671
+                                 lexical-x-2672
+                                 lexical-v-2673
+                                 lexical-e1-2674
+                                 lexical-e2-2675)
+                          (andmap identifier? lexical-x-2672))
+                        lexical-tmp-2670)
+                 '#f)
+             (apply (lambda (lexical-_-2677
+                             lexical-x-2678
+                             lexical-v-2679
+                             lexical-e1-2680
+                             lexical-e2-2681)
+                      (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 lexical-x-2678
+                                        (cons lexical-e1-2680 lexical-e2-2681)))
+                            lexical-v-2679))
+                    lexical-tmp-2670)
+             ((lambda (lexical-tmp-2685)
+                (if (if lexical-tmp-2685
+                        (apply (lambda (lexical-_-2686
+                                        lexical-f-2687
+                                        lexical-x-2688
+                                        lexical-v-2689
+                                        lexical-e1-2690
+                                        lexical-e2-2691)
+                                 (andmap
+                                  identifier?
+                                  (cons lexical-f-2687 lexical-x-2688)))
+                               lexical-tmp-2685)
+                        '#f)
+                    (apply (lambda (lexical-_-2693
+                                    lexical-f-2694
+                                    lexical-x-2695
+                                    lexical-v-2696
+                                    lexical-e1-2697
+                                    lexical-e2-2698)
+                             (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 lexical-f-2694
+                                                     (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 lexical-x-2695
+                                                                 (cons lexical-e1-2697
+                                                                       lexical-e2-2698)))))
+                                         lexical-f-2694)
+                                   lexical-v-2696))
+                           lexical-tmp-2685)
+                    (syntax-error lexical-tmp-2669)))
+              ($syntax-dispatch
+               lexical-tmp-2669
+               '(any any #(each (any any)) any . each-any)))))
+       ($syntax-dispatch
+        lexical-tmp-2669
+        '(any #(each (any any)) any . each-any))))
+    lexical-x-2668))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object let* ((top) #(ribcage #(let*) #((top)) #(let*))))
+ (lambda (lexical-x-2702)
+   ((lambda (lexical-tmp-2703)
+      ((lambda (lexical-tmp-2704)
+         (if (if lexical-tmp-2704
+                 (apply (lambda (lexical-let*-2705
+                                 lexical-x-2706
+                                 lexical-v-2707
+                                 lexical-e1-2708
+                                 lexical-e2-2709)
+                          (andmap identifier? lexical-x-2706))
+                        lexical-tmp-2704)
+                 '#f)
+             (apply (lambda (lexical-let*-2711
+                             lexical-x-2712
+                             lexical-v-2713
+                             lexical-e1-2714
+                             lexical-e2-2715)
+                      ((letrec ((lexical-f-2716
+                                 (lambda (lexical-bindings-2717)
+                                   (if (null? lexical-bindings-2717)
+                                       (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 lexical-e1-2714
+                                                         lexical-e2-2715)))
+                                       ((lambda (lexical-tmp-2719)
+                                          ((lambda (lexical-tmp-2720)
+                                             (if lexical-tmp-2720
+                                                 (apply (lambda (lexical-body-2721
+                                                                 lexical-binding-2722)
+                                                          (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 lexical-binding-2722)
+                                                                lexical-body-2721))
+                                                        lexical-tmp-2720)
+                                                 (syntax-error
+                                                  lexical-tmp-2719)))
+                                           ($syntax-dispatch
+                                            lexical-tmp-2719
+                                            '(any any))))
+                                        (list (lexical-f-2716
+                                               (cdr lexical-bindings-2717))
+                                              (car lexical-bindings-2717)))))))
+                         lexical-f-2716)
+                       (map list lexical-x-2712 lexical-v-2713)))
+                    lexical-tmp-2704)
+             (syntax-error lexical-tmp-2703)))
+       ($syntax-dispatch
+        lexical-tmp-2703
+        '(any #(each (any any)) any . each-any))))
+    lexical-x-2702))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object cond ((top) #(ribcage #(cond) #((top)) #(cond))))
+ (lambda (lexical-x-2726)
+   ((lambda (lexical-tmp-2727)
+      ((lambda (lexical-tmp-2728)
+         (if lexical-tmp-2728
+             (apply (lambda (lexical-_-2729 lexical-m1-2730 lexical-m2-2731)
+                      ((letrec ((lexical-f-2732
+                                 (lambda (lexical-clause-2733
+                                          lexical-clauses-2734)
+                                   (if (null? lexical-clauses-2734)
+                                       ((lambda (lexical-tmp-2735)
+                                          ((lambda (lexical-tmp-2736)
+                                             (if lexical-tmp-2736
+                                                 (apply (lambda (lexical-e1-2737
+                                                                 lexical-e2-2738)
+                                                          (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 lexical-e1-2737
+                                                                      lexical-e2-2738)))
+                                                        lexical-tmp-2736)
+                                                 ((lambda (lexical-tmp-2740)
+                                                    (if lexical-tmp-2740
+                                                        (apply (lambda (lexical-e0-2741)
+                                                                 (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)))
+                                                                                         lexical-e0-2741))
+                                                                             '#(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))))))
+                                                               lexical-tmp-2740)
+                                                        ((lambda (lexical-tmp-2742)
+                                                           (if lexical-tmp-2742
+                                                               (apply (lambda (lexical-e0-2743
+                                                                               lexical-e1-2744)
+                                                                        (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)))
+                                                                                          lexical-e0-2743))
+                                                                              (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 lexical-e1-2744
+                                                                                          '#(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)))))))
+                                                                      lexical-tmp-2742)
+                                                               ((lambda (lexical-tmp-2745)
+                                                                  (if lexical-tmp-2745
+                                                                      (apply (lambda (lexical-e0-2746
+                                                                                      lexical-e1-2747
+                                                                                      lexical-e2-2748)
+                                                                               (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)))
+                                                                                     lexical-e0-2746
+                                                                                     (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 lexical-e1-2747
+                                                                                                 lexical-e2-2748))))
+                                                                             lexical-tmp-2745)
+                                                                      ((lambda (lexical-_-2750)
+                                                                         (syntax-error
+                                                                          lexical-x-2726))
+                                                                       lexical-tmp-2735)))
+                                                                ($syntax-dispatch
+                                                                 lexical-tmp-2735
+                                                                 '(any any
+                                                                       .
+                                                                       each-any)))))
+                                                         ($syntax-dispatch
+                                                          lexical-tmp-2735
+                                                          '(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
+                                                   lexical-tmp-2735
+                                                   '(any)))))
+                                           ($syntax-dispatch
+                                            lexical-tmp-2735
+                                            '(#(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))))
+                                        lexical-clause-2733)
+                                       ((lambda (lexical-tmp-2751)
+                                          ((lambda (lexical-rest-2752)
+                                             ((lambda (lexical-tmp-2753)
+                                                ((lambda (lexical-tmp-2754)
+                                                   (if lexical-tmp-2754
+                                                       (apply (lambda (lexical-e0-2755)
+                                                                (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)))
+                                                                                  lexical-e0-2755))
+                                                                      (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)))
+                                                                            lexical-rest-2752)))
+                                                              lexical-tmp-2754)
+                                                       ((lambda (lexical-tmp-2756)
+                                                          (if lexical-tmp-2756
+                                                              (apply (lambda (lexical-e0-2757
+                                                                              lexical-e1-2758)
+                                                                       (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)))
+                                                                                         lexical-e0-2757))
+                                                                             (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 lexical-e1-2758
+                                                                                         '#(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))))
+                                                                                   lexical-rest-2752)))
+                                                                     lexical-tmp-2756)
+                                                              ((lambda (lexical-tmp-2759)
+                                                                 (if lexical-tmp-2759
+                                                                     (apply (lambda (lexical-e0-2760
+                                                                                     lexical-e1-2761
+                                                                                     lexical-e2-2762)
+                                                                              (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)))
+                                                                                    lexical-e0-2760
+                                                                                    (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 lexical-e1-2761
+                                                                                                lexical-e2-2762))
+                                                                                    lexical-rest-2752))
+                                                                            lexical-tmp-2759)
+                                                                     ((lambda (lexical-_-2764)
+                                                                        (syntax-error
+                                                                         lexical-x-2726))
+                                                                      lexical-tmp-2753)))
+                                                               ($syntax-dispatch
+                                                                lexical-tmp-2753
+                                                                '(any any
+                                                                      .
+                                                                      each-any)))))
+                                                        ($syntax-dispatch
+                                                         lexical-tmp-2753
+                                                         '(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
+                                                  lexical-tmp-2753
+                                                  '(any))))
+                                              lexical-clause-2733))
+                                           lexical-tmp-2751))
+                                        (lexical-f-2732
+                                         (car lexical-clauses-2734)
+                                         (cdr lexical-clauses-2734)))))))
+                         lexical-f-2732)
+                       lexical-m1-2730
+                       lexical-m2-2731))
+                    lexical-tmp-2728)
+             (syntax-error lexical-tmp-2727)))
+       ($syntax-dispatch lexical-tmp-2727 '(any any . each-any))))
+    lexical-x-2726))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object do ((top) #(ribcage #(do) #((top)) #(do))))
+ (lambda (lexical-orig-x-2767)
+   ((lambda (lexical-tmp-2768)
+      ((lambda (lexical-tmp-2769)
+         (if lexical-tmp-2769
+             (apply (lambda (lexical-_-2770
+                             lexical-var-2771
+                             lexical-init-2772
+                             lexical-step-2773
+                             lexical-e0-2774
+                             lexical-e1-2775
+                             lexical-c-2776)
+                      ((lambda (lexical-tmp-2777)
+                         ((lambda (lexical-tmp-2778)
+                            (if lexical-tmp-2778
+                                (apply (lambda (lexical-step-2779)
+                                         ((lambda (lexical-tmp-2780)
+                                            ((lambda (lexical-tmp-2781)
+                                               (if lexical-tmp-2781
+                                                   (apply (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
+                                                                       lexical-var-2771
+                                                                       lexical-init-2772)
+                                                                  (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)))
+                                                                              lexical-e0-2774)
+                                                                        (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
+                                                                               lexical-c-2776
+                                                                               (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)))
+                                                                                           lexical-step-2779)))))))
+                                                          lexical-tmp-2781)
+                                                   ((lambda (lexical-tmp-2786)
+                                                      (if lexical-tmp-2786
+                                                          (apply (lambda (lexical-e1-2787
+                                                                          lexical-e2-2788)
+                                                                   (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
+                                                                              lexical-var-2771
+                                                                              lexical-init-2772)
+                                                                         (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)))
+                                                                               lexical-e0-2774
+                                                                               (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 lexical-e1-2787
+                                                                                           lexical-e2-2788))
+                                                                               (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
+                                                                                      lexical-c-2776
+                                                                                      (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)))
+                                                                                                  lexical-step-2779)))))))
+                                                                 lexical-tmp-2786)
+                                                          (syntax-error
+                                                           lexical-tmp-2780)))
+                                                    ($syntax-dispatch
+                                                     lexical-tmp-2780
+                                                     '(any . each-any)))))
+                                             ($syntax-dispatch
+                                              lexical-tmp-2780
+                                              '())))
+                                          lexical-e1-2775))
+                                       lexical-tmp-2778)
+                                (syntax-error lexical-tmp-2777)))
+                          ($syntax-dispatch lexical-tmp-2777 'each-any)))
+                       (map (lambda (lexical-v-2795 lexical-s-2796)
+                              ((lambda (lexical-tmp-2797)
+                                 ((lambda (lexical-tmp-2798)
+                                    (if lexical-tmp-2798
+                                        (apply (lambda () lexical-v-2795)
+                                               lexical-tmp-2798)
+                                        ((lambda (lexical-tmp-2799)
+                                           (if lexical-tmp-2799
+                                               (apply (lambda (lexical-e-2800)
+                                                        lexical-e-2800)
+                                                      lexical-tmp-2799)
+                                               ((lambda (lexical-_-2801)
+                                                  (syntax-error
+                                                   lexical-orig-x-2767))
+                                                lexical-tmp-2797)))
+                                         ($syntax-dispatch
+                                          lexical-tmp-2797
+                                          '(any)))))
+                                  ($syntax-dispatch lexical-tmp-2797 '())))
+                               lexical-s-2796))
+                            lexical-var-2771
+                            lexical-step-2773)))
+                    lexical-tmp-2769)
+             (syntax-error lexical-tmp-2768)))
+       ($syntax-dispatch
+        lexical-tmp-2768
+        '(any #(each (any any . any)) (any . each-any) . each-any))))
+    lexical-orig-x-2767))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object
+    quasiquote
+    ((top) #(ribcage #(quasiquote) #((top)) #(quasiquote))))
+ ((lambda ()
+    (letrec* ((lexical-quasi-2804
+               (lambda (lexical-p-2811 lexical-lev-2812)
+                 ((lambda (lexical-tmp-2813)
+                    ((lambda (lexical-tmp-2814)
+                       (if lexical-tmp-2814
+                           (apply (lambda (lexical-p-2815)
+                                    (if (= lexical-lev-2812 '0)
+                                        (list '#(syntax-object
+                                                 "value"
+                                                 ((top)
+                                                  #(ribcage
+                                                    #(p)
+                                                    #((top))
+                                                    #("i"))
+                                                  #(ribcage () () ())
+                                                  #(ribcage
+                                                    #(p lev)
+                                                    #((top) (top))
+                                                    #("i" "i"))
+                                                  #(ribcage
+                                                    (emit quasivector
+                                                          quasilist*
+                                                          quasiappend
+                                                          quasicons
+                                                          vquasi
+                                                          quasi)
+                                                    ((top)
+                                                     (top)
+                                                     (top)
+                                                     (top)
+                                                     (top)
+                                                     (top)
+                                                     (top))
+                                                    ("i"
+                                                     "i"
+                                                     "i"
+                                                     "i"
+                                                     "i"
+                                                     "i"
+                                                     "i"))
+                                                  #(top-ribcage *top* #t)))
+                                              lexical-p-2815)
+                                        (lexical-quasicons-2806
+                                         '#(syntax-object
+                                            ("quote" unquote)
+                                            ((top)
+                                             #(ribcage #(p) #((top)) #("i"))
+                                             #(ribcage () () ())
+                                             #(ribcage
+                                               #(p lev)
+                                               #((top) (top))
+                                               #("i" "i"))
+                                             #(ribcage
+                                               (emit quasivector
+                                                     quasilist*
+                                                     quasiappend
+                                                     quasicons
+                                                     vquasi
+                                                     quasi)
+                                               ((top)
+                                                (top)
+                                                (top)
+                                                (top)
+                                                (top)
+                                                (top)
+                                                (top))
+                                               ("i" "i" "i" "i" "i" "i" "i"))
+                                             #(top-ribcage *top* #t)))
+                                         (lexical-quasi-2804
+                                          (list lexical-p-2815)
+                                          (- lexical-lev-2812 '1)))))
+                                  lexical-tmp-2814)
+                           ((lambda (lexical-tmp-2816)
+                              (if lexical-tmp-2816
+                                  (apply (lambda (lexical-p-2817)
+                                           (lexical-quasicons-2806
+                                            '#(syntax-object
+                                               ("quote" quasiquote)
+                                               ((top)
+                                                #(ribcage #(p) #((top)) #("i"))
+                                                #(ribcage () () ())
+                                                #(ribcage
+                                                  #(p lev)
+                                                  #((top) (top))
+                                                  #("i" "i"))
+                                                #(ribcage
+                                                  (emit quasivector
+                                                        quasilist*
+                                                        quasiappend
+                                                        quasicons
+                                                        vquasi
+                                                        quasi)
+                                                  ((top)
+                                                   (top)
+                                                   (top)
+                                                   (top)
+                                                   (top)
+                                                   (top)
+                                                   (top))
+                                                  ("i" "i" "i" "i" "i" "i" "i"))
+                                                #(top-ribcage *top* #t)))
+                                            (lexical-quasi-2804
+                                             (list lexical-p-2817)
+                                             (+ lexical-lev-2812 '1))))
+                                         lexical-tmp-2816)
+                                  ((lambda (lexical-tmp-2818)
+                                     (if lexical-tmp-2818
+                                         (apply (lambda (lexical-p-2819
+                                                         lexical-q-2820)
+                                                  ((lambda (lexical-tmp-2821)
+                                                     ((lambda (lexical-tmp-2822)
+                                                        (if lexical-tmp-2822
+                                                            (apply (lambda (lexical-p-2823)
+                                                                     (if (= lexical-lev-2812
+                                                                            '0)
+                                                                         (lexical-quasilist*-2808
+                                                                          (map (lambda (lexical-tmp-2824)
+                                                                                 (list '#(syntax-object
+                                                                                          "value"
+                                                                                          ((top)
+                                                                                           #(ribcage
+                                                                                             #(p)
+                                                                                             #((top))
+                                                                                             #("i"))
+                                                                                           #(ribcage
+                                                                                             #(p q)
+                                                                                             #((top)
+                                                                                               (top))
+                                                                                             #("i"
+                                                                                               "i"))
+                                                                                           #(ribcage
+                                                                                             ()
+                                                                                             ()
+                                                                                             ())
+                                                                                           #(ribcage
+                                                                                             #(p lev)
+                                                                                             #((top)
+                                                                                               (top))
+                                                                                             #("i"
+                                                                                               "i"))
+                                                                                           #(ribcage
+                                                                                             (emit quasivector
+                                                                                                   quasilist*
+                                                                                                   quasiappend
+                                                                                                   quasicons
+                                                                                                   vquasi
+                                                                                                   quasi)
+                                                                                             ((top)
+                                                                                              (top)
+                                                                                              (top)
+                                                                                              (top)
+                                                                                              (top)
+                                                                                              (top)
+                                                                                              (top))
+                                                                                             ("i"
+                                                                                              "i"
+                                                                                              "i"
+                                                                                              "i"
+                                                                                              "i"
+                                                                                              "i"
+                                                                                              "i"))
+                                                                                           #(top-ribcage
+                                                                                             *top*
+                                                                                             #t)))
+                                                                                       lexical-tmp-2824))
+                                                                               lexical-p-2823)
+                                                                          (lexical-quasi-2804
+                                                                           lexical-q-2820
+                                                                           lexical-lev-2812))
+                                                                         (lexical-quasicons-2806
+                                                                          (lexical-quasicons-2806
+                                                                           '#(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
+                                                                                 (emit quasivector
+                                                                                       quasilist*
+                                                                                       quasiappend
+                                                                                       quasicons
+                                                                                       vquasi
+                                                                                       quasi)
+                                                                                 ((top)
+                                                                                  (top)
+                                                                                  (top)
+                                                                                  (top)
+                                                                                  (top)
+                                                                                  (top)
+                                                                                  (top))
+                                                                                 ("i"
+                                                                                  "i"
+                                                                                  "i"
+                                                                                  "i"
+                                                                                  "i"
+                                                                                  "i"
+                                                                                  "i"))
+                                                                               #(top-ribcage
+                                                                                 *top*
+                                                                                 #t)))
+                                                                           (lexical-quasi-2804
+                                                                            lexical-p-2823
+                                                                            (- lexical-lev-2812
+                                                                               '1)))
+                                                                          (lexical-quasi-2804
+                                                                           lexical-q-2820
+                                                                           lexical-lev-2812))))
+                                                                   lexical-tmp-2822)
+                                                            ((lambda (lexical-tmp-2826)
+                                                               (if lexical-tmp-2826
+                                                                   (apply (lambda (lexical-p-2827)
+                                                                            (if (= lexical-lev-2812
+                                                                                   '0)
+                                                                                (lexical-quasiappend-2807
+                                                                                 (map (lambda (lexical-tmp-2828)
+                                                                                        (list '#(syntax-object
+                                                                                                 "value"
+                                                                                                 ((top)
+                                                                                                  #(ribcage
+                                                                                                    #(p)
+                                                                                                    #((top))
+                                                                                                    #("i"))
+                                                                                                  #(ribcage
+                                                                                                    #(p q)
+                                                                                                    #((top)
+                                                                                                      (top))
+                                                                                                    #("i"
+                                                                                                      "i"))
+                                                                                                  #(ribcage
+                                                                                                    ()
+                                                                                                    ()
+                                                                                                    ())
+                                                                                                  #(ribcage
+                                                                                                    #(p lev)
+                                                                                                    #((top)
+                                                                                                      (top))
+                                                                                                    #("i"
+                                                                                                      "i"))
+                                                                                                  #(ribcage
+                                                                                                    (emit quasivector
+                                                                                                          quasilist*
+                                                                                                          quasiappend
+                                                                                                          quasicons
+                                                                                                          vquasi
+                                                                                                          quasi)
+                                                                                                    ((top)
+                                                                                                     (top)
+                                                                                                     (top)
+                                                                                                     (top)
+                                                                                                     (top)
+                                                                                                     (top)
+                                                                                                     (top))
+                                                                                                    ("i"
+                                                                                                     "i"
+                                                                                                     "i"
+                                                                                                     "i"
+                                                                                                     "i"
+                                                                                                     "i"
+                                                                                                     "i"))
+                                                                                                  #(top-ribcage
+                                                                                                    *top*
+                                                                                                    #t)))
+                                                                                              lexical-tmp-2828))
+                                                                                      lexical-p-2827)
+                                                                                 (lexical-quasi-2804
+                                                                                  lexical-q-2820
+                                                                                  lexical-lev-2812))
+                                                                                (lexical-quasicons-2806
+                                                                                 (lexical-quasicons-2806
+                                                                                  '#(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
+                                                                                        (emit quasivector
+                                                                                              quasilist*
+                                                                                              quasiappend
+                                                                                              quasicons
+                                                                                              vquasi
+                                                                                              quasi)
+                                                                                        ((top)
+                                                                                         (top)
+                                                                                         (top)
+                                                                                         (top)
+                                                                                         (top)
+                                                                                         (top)
+                                                                                         (top))
+                                                                                        ("i"
+                                                                                         "i"
+                                                                                         "i"
+                                                                                         "i"
+                                                                                         "i"
+                                                                                         "i"
+                                                                                         "i"))
+                                                                                      #(top-ribcage
+                                                                                        *top*
+                                                                                        #t)))
+                                                                                  (lexical-quasi-2804
+                                                                                   lexical-p-2827
+                                                                                   (- lexical-lev-2812
+                                                                                      '1)))
+                                                                                 (lexical-quasi-2804
+                                                                                  lexical-q-2820
+                                                                                  lexical-lev-2812))))
+                                                                          lexical-tmp-2826)
+                                                                   ((lambda (lexical-_-2830)
+                                                                      (lexical-quasicons-2806
+                                                                       (lexical-quasi-2804
+                                                                        lexical-p-2819
+                                                                        lexical-lev-2812)
+                                                                       (lexical-quasi-2804
+                                                                        lexical-q-2820
+                                                                        lexical-lev-2812)))
+                                                                    lexical-tmp-2821)))
+                                                             ($syntax-dispatch
+                                                              lexical-tmp-2821
+                                                              '(#(free-id
+                                                                  #(syntax-object
+                                                                    unquote-splicing
+                                                                    ((top)
+                                                                     #(ribcage
+                                                                       #(p q)
+                                                                       #((top)
+                                                                         (top))
+                                                                       #("i"
+                                                                         "i"))
+                                                                     #(ribcage
+                                                                       ()
+                                                                       ()
+                                                                       ())
+                                                                     #(ribcage
+                                                                       #(p lev)
+                                                                       #((top)
+                                                                         (top))
+                                                                       #("i"
+                                                                         "i"))
+                                                                     #(ribcage
+                                                                       (emit quasivector
+                                                                             quasilist*
+                                                                             quasiappend
+                                                                             quasicons
+                                                                             vquasi
+                                                                             quasi)
+                                                                       ((top)
+                                                                        (top)
+                                                                        (top)
+                                                                        (top)
+                                                                        (top)
+                                                                        (top)
+                                                                        (top))
+                                                                       ("i"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"
+                                                                        "i"))
+                                                                     #(top-ribcage
+                                                                       *top*
+                                                                       #t))))
+                                                                .
+                                                                each-any)))))
+                                                      ($syntax-dispatch
+                                                       lexical-tmp-2821
+                                                       '(#(free-id
+                                                           #(syntax-object
+                                                             unquote
+                                                             ((top)
+                                                              #(ribcage
+                                                                #(p q)
+                                                                #((top) (top))
+                                                                #("i" "i"))
+                                                              #(ribcage
+                                                                ()
+                                                                ()
+                                                                ())
+                                                              #(ribcage
+                                                                #(p lev)
+                                                                #((top) (top))
+                                                                #("i" "i"))
+                                                              #(ribcage
+                                                                (emit quasivector
+                                                                      quasilist*
+                                                                      quasiappend
+                                                                      quasicons
+                                                                      vquasi
+                                                                      quasi)
+                                                                ((top)
+                                                                 (top)
+                                                                 (top)
+                                                                 (top)
+                                                                 (top)
+                                                                 (top)
+                                                                 (top))
+                                                                ("i"
+                                                                 "i"
+                                                                 "i"
+                                                                 "i"
+                                                                 "i"
+                                                                 "i"
+                                                                 "i"))
+                                                              #(top-ribcage
+                                                                *top*
+                                                                #t))))
+                                                         .
+                                                         each-any))))
+                                                   lexical-p-2819))
+                                                lexical-tmp-2818)
+                                         ((lambda (lexical-tmp-2831)
+                                            (if lexical-tmp-2831
+                                                (apply (lambda (lexical-x-2832)
+                                                         (lexical-quasivector-2809
+                                                          (lexical-vquasi-2805
+                                                           lexical-x-2832
+                                                           lexical-lev-2812)))
+                                                       lexical-tmp-2831)
+                                                ((lambda (lexical-p-2834)
+                                                   (list '#(syntax-object
+                                                            "quote"
+                                                            ((top)
+                                                             #(ribcage
+                                                               #(p)
+                                                               #((top))
+                                                               #("i"))
+                                                             #(ribcage
+                                                               ()
+                                                               ()
+                                                               ())
+                                                             #(ribcage
+                                                               #(p lev)
+                                                               #((top) (top))
+                                                               #("i" "i"))
+                                                             #(ribcage
+                                                               (emit quasivector
+                                                                     quasilist*
+                                                                     quasiappend
+                                                                     quasicons
+                                                                     vquasi
+                                                                     quasi)
+                                                               ((top)
+                                                                (top)
+                                                                (top)
+                                                                (top)
+                                                                (top)
+                                                                (top)
+                                                                (top))
+                                                               ("i"
+                                                                "i"
+                                                                "i"
+                                                                "i"
+                                                                "i"
+                                                                "i"
+                                                                "i"))
+                                                             #(top-ribcage
+                                                               *top*
+                                                               #t)))
+                                                         lexical-p-2834))
+                                                 lexical-tmp-2813)))
+                                          ($syntax-dispatch
+                                           lexical-tmp-2813
+                                           '#(vector each-any)))))
+                                   ($syntax-dispatch
+                                    lexical-tmp-2813
+                                    '(any . any)))))
+                            ($syntax-dispatch
+                             lexical-tmp-2813
+                             '(#(free-id
+                                 #(syntax-object
+                                   quasiquote
+                                   ((top)
+                                    #(ribcage () () ())
+                                    #(ribcage
+                                      #(p lev)
+                                      #((top) (top))
+                                      #("i" "i"))
+                                    #(ribcage
+                                      (emit quasivector
+                                            quasilist*
+                                            quasiappend
+                                            quasicons
+                                            vquasi
+                                            quasi)
+                                      ((top)
+                                       (top)
+                                       (top)
+                                       (top)
+                                       (top)
+                                       (top)
+                                       (top))
+                                      ("i" "i" "i" "i" "i" "i" "i"))
+                                    #(top-ribcage *top* #t))))
+                               any)))))
+                     ($syntax-dispatch
+                      lexical-tmp-2813
+                      '(#(free-id
+                          #(syntax-object
+                            unquote
+                            ((top)
+                             #(ribcage () () ())
+                             #(ribcage #(p lev) #((top) (top)) #("i" "i"))
+                             #(ribcage
+                               (emit quasivector
+                                     quasilist*
+                                     quasiappend
+                                     quasicons
+                                     vquasi
+                                     quasi)
+                               ((top) (top) (top) (top) (top) (top) (top))
+                               ("i" "i" "i" "i" "i" "i" "i"))
+                             #(top-ribcage *top* #t))))
+                        any))))
+                  lexical-p-2811)))
+              (lexical-vquasi-2805
+               (lambda (lexical-p-2835 lexical-lev-2836)
+                 ((lambda (lexical-tmp-2837)
+                    ((lambda (lexical-tmp-2838)
+                       (if lexical-tmp-2838
+                           (apply (lambda (lexical-p-2839 lexical-q-2840)
+                                    ((lambda (lexical-tmp-2841)
+                                       ((lambda (lexical-tmp-2842)
+                                          (if lexical-tmp-2842
+                                              (apply (lambda (lexical-p-2843)
+                                                       (if (= lexical-lev-2836
+                                                              '0)
+                                                           (lexical-quasilist*-2808
+                                                            (map (lambda (lexical-tmp-2844)
+                                                                   (list '#(syntax-object
+                                                                            "value"
+                                                                            ((top)
+                                                                             #(ribcage
+                                                                               #(p)
+                                                                               #((top))
+                                                                               #("i"))
+                                                                             #(ribcage
+                                                                               #(p q)
+                                                                               #((top)
+                                                                                 (top))
+                                                                               #("i"
+                                                                                 "i"))
+                                                                             #(ribcage
+                                                                               ()
+                                                                               ()
+                                                                               ())
+                                                                             #(ribcage
+                                                                               #(p lev)
+                                                                               #((top)
+                                                                                 (top))
+                                                                               #("i"
+                                                                                 "i"))
+                                                                             #(ribcage
+                                                                               (emit quasivector
+                                                                                     quasilist*
+                                                                                     quasiappend
+                                                                                     quasicons
+                                                                                     vquasi
+                                                                                     quasi)
+                                                                               ((top)
+                                                                                (top)
+                                                                                (top)
+                                                                                (top)
+                                                                                (top)
+                                                                                (top)
+                                                                                (top))
+                                                                               ("i"
+                                                                                "i"
+                                                                                "i"
+                                                                                "i"
+                                                                                "i"
+                                                                                "i"
+                                                                                "i"))
+                                                                             #(top-ribcage
+                                                                               *top*
+                                                                               #t)))
+                                                                         lexical-tmp-2844))
+                                                                 lexical-p-2843)
+                                                            (lexical-vquasi-2805
+                                                             lexical-q-2840
+                                                             lexical-lev-2836))
+                                                           (lexical-quasicons-2806
+                                                            (lexical-quasicons-2806
+                                                             '#(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
+                                                                   (emit quasivector
+                                                                         quasilist*
+                                                                         quasiappend
+                                                                         quasicons
+                                                                         vquasi
+                                                                         quasi)
+                                                                   ((top)
+                                                                    (top)
+                                                                    (top)
+                                                                    (top)
+                                                                    (top)
+                                                                    (top)
+                                                                    (top))
+                                                                   ("i"
+                                                                    "i"
+                                                                    "i"
+                                                                    "i"
+                                                                    "i"
+                                                                    "i"
+                                                                    "i"))
+                                                                 #(top-ribcage
+                                                                   *top*
+                                                                   #t)))
+                                                             (lexical-quasi-2804
+                                                              lexical-p-2843
+                                                              (- lexical-lev-2836
+                                                                 '1)))
+                                                            (lexical-vquasi-2805
+                                                             lexical-q-2840
+                                                             lexical-lev-2836))))
+                                                     lexical-tmp-2842)
+                                              ((lambda (lexical-tmp-2846)
+                                                 (if lexical-tmp-2846
+                                                     (apply (lambda (lexical-p-2847)
+                                                              (if (= lexical-lev-2836
+                                                                     '0)
+                                                                  (lexical-quasiappend-2807
+                                                                   (map (lambda (lexical-tmp-2848)
+                                                                          (list '#(syntax-object
+                                                                                   "value"
+                                                                                   ((top)
+                                                                                    #(ribcage
+                                                                                      #(p)
+                                                                                      #((top))
+                                                                                      #("i"))
+                                                                                    #(ribcage
+                                                                                      #(p q)
+                                                                                      #((top)
+                                                                                        (top))
+                                                                                      #("i"
+                                                                                        "i"))
+                                                                                    #(ribcage
+                                                                                      ()
+                                                                                      ()
+                                                                                      ())
+                                                                                    #(ribcage
+                                                                                      #(p lev)
+                                                                                      #((top)
+                                                                                        (top))
+                                                                                      #("i"
+                                                                                        "i"))
+                                                                                    #(ribcage
+                                                                                      (emit quasivector
+                                                                                            quasilist*
+                                                                                            quasiappend
+                                                                                            quasicons
+                                                                                            vquasi
+                                                                                            quasi)
+                                                                                      ((top)
+                                                                                       (top)
+                                                                                       (top)
+                                                                                       (top)
+                                                                                       (top)
+                                                                                       (top)
+                                                                                       (top))
+                                                                                      ("i"
+                                                                                       "i"
+                                                                                       "i"
+                                                                                       "i"
+                                                                                       "i"
+                                                                                       "i"
+                                                                                       "i"))
+                                                                                    #(top-ribcage
+                                                                                      *top*
+                                                                                      #t)))
+                                                                                lexical-tmp-2848))
+                                                                        lexical-p-2847)
+                                                                   (lexical-vquasi-2805
+                                                                    lexical-q-2840
+                                                                    lexical-lev-2836))
+                                                                  (lexical-quasicons-2806
+                                                                   (lexical-quasicons-2806
+                                                                    '#(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
+                                                                          (emit quasivector
+                                                                                quasilist*
+                                                                                quasiappend
+                                                                                quasicons
+                                                                                vquasi
+                                                                                quasi)
+                                                                          ((top)
+                                                                           (top)
+                                                                           (top)
+                                                                           (top)
+                                                                           (top)
+                                                                           (top)
+                                                                           (top))
+                                                                          ("i"
+                                                                           "i"
+                                                                           "i"
+                                                                           "i"
+                                                                           "i"
+                                                                           "i"
+                                                                           "i"))
+                                                                        #(top-ribcage
+                                                                          *top*
+                                                                          #t)))
+                                                                    (lexical-quasi-2804
+                                                                     lexical-p-2847
+                                                                     (- lexical-lev-2836
+                                                                        '1)))
+                                                                   (lexical-vquasi-2805
+                                                                    lexical-q-2840
+                                                                    lexical-lev-2836))))
+                                                            lexical-tmp-2846)
+                                                     ((lambda (lexical-_-2850)
+                                                        (lexical-quasicons-2806
+                                                         (lexical-quasi-2804
+                                                          lexical-p-2839
+                                                          lexical-lev-2836)
+                                                         (lexical-vquasi-2805
+                                                          lexical-q-2840
+                                                          lexical-lev-2836)))
+                                                      lexical-tmp-2841)))
+                                               ($syntax-dispatch
+                                                lexical-tmp-2841
+                                                '(#(free-id
+                                                    #(syntax-object
+                                                      unquote-splicing
+                                                      ((top)
+                                                       #(ribcage
+                                                         #(p q)
+                                                         #((top) (top))
+                                                         #("i" "i"))
+                                                       #(ribcage () () ())
+                                                       #(ribcage
+                                                         #(p lev)
+                                                         #((top) (top))
+                                                         #("i" "i"))
+                                                       #(ribcage
+                                                         (emit quasivector
+                                                               quasilist*
+                                                               quasiappend
+                                                               quasicons
+                                                               vquasi
+                                                               quasi)
+                                                         ((top)
+                                                          (top)
+                                                          (top)
+                                                          (top)
+                                                          (top)
+                                                          (top)
+                                                          (top))
+                                                         ("i"
+                                                          "i"
+                                                          "i"
+                                                          "i"
+                                                          "i"
+                                                          "i"
+                                                          "i"))
+                                                       #(top-ribcage *top* #t))))
+                                                  .
+                                                  each-any)))))
+                                        ($syntax-dispatch
+                                         lexical-tmp-2841
+                                         '(#(free-id
+                                             #(syntax-object
+                                               unquote
+                                               ((top)
+                                                #(ribcage
+                                                  #(p q)
+                                                  #((top) (top))
+                                                  #("i" "i"))
+                                                #(ribcage () () ())
+                                                #(ribcage
+                                                  #(p lev)
+                                                  #((top) (top))
+                                                  #("i" "i"))
+                                                #(ribcage
+                                                  (emit quasivector
+                                                        quasilist*
+                                                        quasiappend
+                                                        quasicons
+                                                        vquasi
+                                                        quasi)
+                                                  ((top)
+                                                   (top)
+                                                   (top)
+                                                   (top)
+                                                   (top)
+                                                   (top)
+                                                   (top))
+                                                  ("i" "i" "i" "i" "i" "i" "i"))
+                                                #(top-ribcage *top* #t))))
+                                           .
+                                           each-any))))
+                                     lexical-p-2839))
+                                  lexical-tmp-2838)
+                           ((lambda (lexical-tmp-2851)
+                              (if lexical-tmp-2851
+                                  (apply (lambda ()
+                                           '#(syntax-object
+                                              ("quote" ())
+                                              ((top)
+                                               #(ribcage () () ())
+                                               #(ribcage
+                                                 #(p lev)
+                                                 #((top) (top))
+                                                 #("i" "i"))
+                                               #(ribcage
+                                                 (emit quasivector
+                                                       quasilist*
+                                                       quasiappend
+                                                       quasicons
+                                                       vquasi
+                                                       quasi)
+                                                 ((top)
+                                                  (top)
+                                                  (top)
+                                                  (top)
+                                                  (top)
+                                                  (top)
+                                                  (top))
+                                                 ("i" "i" "i" "i" "i" "i" "i"))
+                                               #(top-ribcage *top* #t))))
+                                         lexical-tmp-2851)
+                                  (syntax-error lexical-tmp-2837)))
+                            ($syntax-dispatch lexical-tmp-2837 '()))))
+                     ($syntax-dispatch lexical-tmp-2837 '(any . any))))
+                  lexical-p-2835)))
+              (lexical-quasicons-2806
+               (lambda (lexical-x-2852 lexical-y-2853)
+                 ((lambda (lexical-tmp-2854)
+                    ((lambda (lexical-tmp-2855)
+                       (if lexical-tmp-2855
+                           (apply (lambda (lexical-x-2856 lexical-y-2857)
+                                    ((lambda (lexical-tmp-2858)
+                                       ((lambda (lexical-tmp-2859)
+                                          (if lexical-tmp-2859
+                                              (apply (lambda (lexical-dy-2860)
+                                                       ((lambda (lexical-tmp-2861)
+                                                          ((lambda (lexical-tmp-2862)
+                                                             (if lexical-tmp-2862
+                                                                 (apply (lambda (lexical-dx-2863)
+                                                                          (list '#(syntax-object
+                                                                                   "quote"
+                                                                                   ((top)
+                                                                                    #(ribcage
+                                                                                      #(dx)
+                                                                                      #((top))
+                                                                                      #("i"))
+                                                                                    #(ribcage
+                                                                                      #(dy)
+                                                                                      #((top))
+                                                                                      #("i"))
+                                                                                    #(ribcage
+                                                                                      #(x y)
+                                                                                      #((top)
+                                                                                        (top))
+                                                                                      #("i"
+                                                                                        "i"))
+                                                                                    #(ribcage
+                                                                                      ()
+                                                                                      ()
+                                                                                      ())
+                                                                                    #(ribcage
+                                                                                      #(x y)
+                                                                                      #((top)
+                                                                                        (top))
+                                                                                      #("i"
+                                                                                        "i"))
+                                                                                    #(ribcage
+                                                                                      (emit quasivector
+                                                                                            quasilist*
+                                                                                            quasiappend
+                                                                                            quasicons
+                                                                                            vquasi
+                                                                                            quasi)
+                                                                                      ((top)
+                                                                                       (top)
+                                                                                       (top)
+                                                                                       (top)
+                                                                                       (top)
+                                                                                       (top)
+                                                                                       (top))
+                                                                                      ("i"
+                                                                                       "i"
+                                                                                       "i"
+                                                                                       "i"
+                                                                                       "i"
+                                                                                       "i"
+                                                                                       "i"))
+                                                                                    #(top-ribcage
+                                                                                      *top*
+                                                                                      #t)))
+                                                                                (cons lexical-dx-2863
+                                                                                      lexical-dy-2860)))
+                                                                        lexical-tmp-2862)
+                                                                 ((lambda (lexical-_-2864)
+                                                                    (if (null? lexical-dy-2860)
+                                                                        (list '#(syntax-object
+                                                                                 "list"
+                                                                                 ((top)
+                                                                                  #(ribcage
+                                                                                    #(_)
+                                                                                    #((top))
+                                                                                    #("i"))
+                                                                                  #(ribcage
+                                                                                    #(dy)
+                                                                                    #((top))
+                                                                                    #("i"))
+                                                                                  #(ribcage
+                                                                                    #(x y)
+                                                                                    #((top)
+                                                                                      (top))
+                                                                                    #("i"
+                                                                                      "i"))
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    #(x y)
+                                                                                    #((top)
+                                                                                      (top))
+                                                                                    #("i"
+                                                                                      "i"))
+                                                                                  #(ribcage
+                                                                                    (emit quasivector
+                                                                                          quasilist*
+                                                                                          quasiappend
+                                                                                          quasicons
+                                                                                          vquasi
+                                                                                          quasi)
+                                                                                    ((top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top))
+                                                                                    ("i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"))
+                                                                                  #(top-ribcage
+                                                                                    *top*
+                                                                                    #t)))
+                                                                              lexical-x-2856)
+                                                                        (list '#(syntax-object
+                                                                                 "list*"
+                                                                                 ((top)
+                                                                                  #(ribcage
+                                                                                    #(_)
+                                                                                    #((top))
+                                                                                    #("i"))
+                                                                                  #(ribcage
+                                                                                    #(dy)
+                                                                                    #((top))
+                                                                                    #("i"))
+                                                                                  #(ribcage
+                                                                                    #(x y)
+                                                                                    #((top)
+                                                                                      (top))
+                                                                                    #("i"
+                                                                                      "i"))
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    #(x y)
+                                                                                    #((top)
+                                                                                      (top))
+                                                                                    #("i"
+                                                                                      "i"))
+                                                                                  #(ribcage
+                                                                                    (emit quasivector
+                                                                                          quasilist*
+                                                                                          quasiappend
+                                                                                          quasicons
+                                                                                          vquasi
+                                                                                          quasi)
+                                                                                    ((top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top))
+                                                                                    ("i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"))
+                                                                                  #(top-ribcage
+                                                                                    *top*
+                                                                                    #t)))
+                                                                              lexical-x-2856
+                                                                              lexical-y-2857)))
+                                                                  lexical-tmp-2861)))
+                                                           ($syntax-dispatch
+                                                            lexical-tmp-2861
+                                                            '(#(atom "quote")
+                                                              any))))
+                                                        lexical-x-2856))
+                                                     lexical-tmp-2859)
+                                              ((lambda (lexical-tmp-2865)
+                                                 (if lexical-tmp-2865
+                                                     (apply (lambda (lexical-stuff-2866)
+                                                              (cons '#(syntax-object
+                                                                       "list"
+                                                                       ((top)
+                                                                        #(ribcage
+                                                                          #(stuff)
+                                                                          #((top))
+                                                                          #("i"))
+                                                                        #(ribcage
+                                                                          #(x y)
+                                                                          #((top)
+                                                                            (top))
+                                                                          #("i"
+                                                                            "i"))
+                                                                        #(ribcage
+                                                                          ()
+                                                                          ()
+                                                                          ())
+                                                                        #(ribcage
+                                                                          #(x y)
+                                                                          #((top)
+                                                                            (top))
+                                                                          #("i"
+                                                                            "i"))
+                                                                        #(ribcage
+                                                                          (emit quasivector
+                                                                                quasilist*
+                                                                                quasiappend
+                                                                                quasicons
+                                                                                vquasi
+                                                                                quasi)
+                                                                          ((top)
+                                                                           (top)
+                                                                           (top)
+                                                                           (top)
+                                                                           (top)
+                                                                           (top)
+                                                                           (top))
+                                                                          ("i"
+                                                                           "i"
+                                                                           "i"
+                                                                           "i"
+                                                                           "i"
+                                                                           "i"
+                                                                           "i"))
+                                                                        #(top-ribcage
+                                                                          *top*
+                                                                          #t)))
+                                                                    (cons lexical-x-2856
+                                                                          lexical-stuff-2866)))
+                                                            lexical-tmp-2865)
+                                                     ((lambda (lexical-tmp-2867)
+                                                        (if lexical-tmp-2867
+                                                            (apply (lambda (lexical-stuff-2868)
+                                                                     (cons '#(syntax-object
+                                                                              "list*"
+                                                                              ((top)
+                                                                               #(ribcage
+                                                                                 #(stuff)
+                                                                                 #((top))
+                                                                                 #("i"))
+                                                                               #(ribcage
+                                                                                 #(x y)
+                                                                                 #((top)
+                                                                                   (top))
+                                                                                 #("i"
+                                                                                   "i"))
+                                                                               #(ribcage
+                                                                                 ()
+                                                                                 ()
+                                                                                 ())
+                                                                               #(ribcage
+                                                                                 #(x y)
+                                                                                 #((top)
+                                                                                   (top))
+                                                                                 #("i"
+                                                                                   "i"))
+                                                                               #(ribcage
+                                                                                 (emit quasivector
+                                                                                       quasilist*
+                                                                                       quasiappend
+                                                                                       quasicons
+                                                                                       vquasi
+                                                                                       quasi)
+                                                                                 ((top)
+                                                                                  (top)
+                                                                                  (top)
+                                                                                  (top)
+                                                                                  (top)
+                                                                                  (top)
+                                                                                  (top))
+                                                                                 ("i"
+                                                                                  "i"
+                                                                                  "i"
+                                                                                  "i"
+                                                                                  "i"
+                                                                                  "i"
+                                                                                  "i"))
+                                                                               #(top-ribcage
+                                                                                 *top*
+                                                                                 #t)))
+                                                                           (cons lexical-x-2856
+                                                                                 lexical-stuff-2868)))
+                                                                   lexical-tmp-2867)
+                                                            ((lambda (lexical-_-2869)
+                                                               (list '#(syntax-object
+                                                                        "list*"
+                                                                        ((top)
+                                                                         #(ribcage
+                                                                           #(_)
+                                                                           #((top))
+                                                                           #("i"))
+                                                                         #(ribcage
+                                                                           #(x y)
+                                                                           #((top)
+                                                                             (top))
+                                                                           #("i"
+                                                                             "i"))
+                                                                         #(ribcage
+                                                                           ()
+                                                                           ()
+                                                                           ())
+                                                                         #(ribcage
+                                                                           #(x y)
+                                                                           #((top)
+                                                                             (top))
+                                                                           #("i"
+                                                                             "i"))
+                                                                         #(ribcage
+                                                                           (emit quasivector
+                                                                                 quasilist*
+                                                                                 quasiappend
+                                                                                 quasicons
+                                                                                 vquasi
+                                                                                 quasi)
+                                                                           ((top)
+                                                                            (top)
+                                                                            (top)
+                                                                            (top)
+                                                                            (top)
+                                                                            (top)
+                                                                            (top))
+                                                                           ("i"
+                                                                            "i"
+                                                                            "i"
+                                                                            "i"
+                                                                            "i"
+                                                                            "i"
+                                                                            "i"))
+                                                                         #(top-ribcage
+                                                                           *top*
+                                                                           #t)))
+                                                                     lexical-x-2856
+                                                                     lexical-y-2857))
+                                                             lexical-tmp-2858)))
+                                                      ($syntax-dispatch
+                                                       lexical-tmp-2858
+                                                       '(#(atom "list*") . any)))))
+                                               ($syntax-dispatch
+                                                lexical-tmp-2858
+                                                '(#(atom "list") . any)))))
+                                        ($syntax-dispatch
+                                         lexical-tmp-2858
+                                         '(#(atom "quote") any))))
+                                     lexical-y-2857))
+                                  lexical-tmp-2855)
+                           (syntax-error lexical-tmp-2854)))
+                     ($syntax-dispatch lexical-tmp-2854 '(any any))))
+                  (list lexical-x-2852 lexical-y-2853))))
+              (lexical-quasiappend-2807
+               (lambda (lexical-x-2870 lexical-y-2871)
+                 ((lambda (lexical-tmp-2872)
+                    ((lambda (lexical-tmp-2873)
+                       (if lexical-tmp-2873
+                           (apply (lambda ()
+                                    (if (null? lexical-x-2870)
+                                        '#(syntax-object
+                                           ("quote" ())
+                                           ((top)
+                                            #(ribcage () () ())
+                                            #(ribcage
+                                              #(x y)
+                                              #((top) (top))
+                                              #("i" "i"))
+                                            #(ribcage
+                                              (emit quasivector
+                                                    quasilist*
+                                                    quasiappend
+                                                    quasicons
+                                                    vquasi
+                                                    quasi)
+                                              ((top)
+                                               (top)
+                                               (top)
+                                               (top)
+                                               (top)
+                                               (top)
+                                               (top))
+                                              ("i" "i" "i" "i" "i" "i" "i"))
+                                            #(top-ribcage *top* #t)))
+                                        (if (null? (cdr lexical-x-2870))
+                                            (car lexical-x-2870)
+                                            ((lambda (lexical-tmp-2874)
+                                               ((lambda (lexical-tmp-2875)
+                                                  (if lexical-tmp-2875
+                                                      (apply (lambda (lexical-p-2876)
+                                                               (cons '#(syntax-object
+                                                                        "append"
+                                                                        ((top)
+                                                                         #(ribcage
+                                                                           #(p)
+                                                                           #((top))
+                                                                           #("i"))
+                                                                         #(ribcage
+                                                                           ()
+                                                                           ()
+                                                                           ())
+                                                                         #(ribcage
+                                                                           #(x y)
+                                                                           #((top)
+                                                                             (top))
+                                                                           #("i"
+                                                                             "i"))
+                                                                         #(ribcage
+                                                                           (emit quasivector
+                                                                                 quasilist*
+                                                                                 quasiappend
+                                                                                 quasicons
+                                                                                 vquasi
+                                                                                 quasi)
+                                                                           ((top)
+                                                                            (top)
+                                                                            (top)
+                                                                            (top)
+                                                                            (top)
+                                                                            (top)
+                                                                            (top))
+                                                                           ("i"
+                                                                            "i"
+                                                                            "i"
+                                                                            "i"
+                                                                            "i"
+                                                                            "i"
+                                                                            "i"))
+                                                                         #(top-ribcage
+                                                                           *top*
+                                                                           #t)))
+                                                                     lexical-p-2876))
+                                                             lexical-tmp-2875)
+                                                      (syntax-error
+                                                       lexical-tmp-2874)))
+                                                ($syntax-dispatch
+                                                 lexical-tmp-2874
+                                                 'each-any)))
+                                             lexical-x-2870))))
+                                  lexical-tmp-2873)
+                           ((lambda (lexical-_-2878)
+                              (if (null? lexical-x-2870)
+                                  lexical-y-2871
+                                  ((lambda (lexical-tmp-2879)
+                                     ((lambda (lexical-tmp-2880)
+                                        (if lexical-tmp-2880
+                                            (apply (lambda (lexical-p-2881
+                                                            lexical-y-2882)
+                                                     (cons '#(syntax-object
+                                                              "append"
+                                                              ((top)
+                                                               #(ribcage
+                                                                 #(p y)
+                                                                 #((top) (top))
+                                                                 #("i" "i"))
+                                                               #(ribcage
+                                                                 #(_)
+                                                                 #((top))
+                                                                 #("i"))
+                                                               #(ribcage
+                                                                 ()
+                                                                 ()
+                                                                 ())
+                                                               #(ribcage
+                                                                 #(x y)
+                                                                 #((top) (top))
+                                                                 #("i" "i"))
+                                                               #(ribcage
+                                                                 (emit quasivector
+                                                                       quasilist*
+                                                                       quasiappend
+                                                                       quasicons
+                                                                       vquasi
+                                                                       quasi)
+                                                                 ((top)
+                                                                  (top)
+                                                                  (top)
+                                                                  (top)
+                                                                  (top)
+                                                                  (top)
+                                                                  (top))
+                                                                 ("i"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"
+                                                                  "i"))
+                                                               #(top-ribcage
+                                                                 *top*
+                                                                 #t)))
+                                                           (append
+                                                            lexical-p-2881
+                                                            (list lexical-y-2882))))
+                                                   lexical-tmp-2880)
+                                            (syntax-error lexical-tmp-2879)))
+                                      ($syntax-dispatch
+                                       lexical-tmp-2879
+                                       '(each-any any))))
+                                   (list lexical-x-2870 lexical-y-2871))))
+                            lexical-tmp-2872)))
+                     ($syntax-dispatch lexical-tmp-2872 '(#(atom "quote") ()))))
+                  lexical-y-2871)))
+              (lexical-quasilist*-2808
+               (lambda (lexical-x-2884 lexical-y-2885)
+                 ((letrec ((lexical-f-2886
+                            (lambda (lexical-x-2887)
+                              (if (null? lexical-x-2887)
+                                  lexical-y-2885
+                                  (lexical-quasicons-2806
+                                   (car lexical-x-2887)
+                                   (lexical-f-2886 (cdr lexical-x-2887)))))))
+                    lexical-f-2886)
+                  lexical-x-2884)))
+              (lexical-quasivector-2809
+               (lambda (lexical-x-2888)
+                 ((lambda (lexical-tmp-2889)
+                    ((lambda (lexical-tmp-2890)
+                       (if lexical-tmp-2890
+                           (apply (lambda (lexical-x-2891)
+                                    (list '#(syntax-object
+                                             "quote"
+                                             ((top)
+                                              #(ribcage #(x) #((top)) #("i"))
+                                              #(ribcage () () ())
+                                              #(ribcage #(x) #((top)) #("i"))
+                                              #(ribcage
+                                                (emit quasivector
+                                                      quasilist*
+                                                      quasiappend
+                                                      quasicons
+                                                      vquasi
+                                                      quasi)
+                                                ((top)
+                                                 (top)
+                                                 (top)
+                                                 (top)
+                                                 (top)
+                                                 (top)
+                                                 (top))
+                                                ("i" "i" "i" "i" "i" "i" "i"))
+                                              #(top-ribcage *top* #t)))
+                                          (list->vector lexical-x-2891)))
+                                  lexical-tmp-2890)
+                           ((lambda (lexical-_-2893)
+                              ((letrec ((lexical-f-2894
+                                         (lambda (lexical-y-2895
+                                                  lexical-k-2896)
+                                           ((lambda (lexical-tmp-2897)
+                                              ((lambda (lexical-tmp-2898)
+                                                 (if lexical-tmp-2898
+                                                     (apply (lambda (lexical-y-2899)
+                                                              (lexical-k-2896
+                                                               (map (lambda (lexical-tmp-2900)
+                                                                      (list '#(syntax-object
+                                                                               "quote"
+                                                                               ((top)
+                                                                                #(ribcage
+                                                                                  #(y)
+                                                                                  #((top))
+                                                                                  #("i"))
+                                                                                #(ribcage
+                                                                                  ()
+                                                                                  ()
+                                                                                  ())
+                                                                                #(ribcage
+                                                                                  #(y k)
+                                                                                  #((top)
+                                                                                    (top))
+                                                                                  #("i"
+                                                                                    "i"))
+                                                                                #(ribcage
+                                                                                  #(f)
+                                                                                  #((top))
+                                                                                  #("i"))
+                                                                                #(ribcage
+                                                                                  #(_)
+                                                                                  #((top))
+                                                                                  #("i"))
+                                                                                #(ribcage
+                                                                                  ()
+                                                                                  ()
+                                                                                  ())
+                                                                                #(ribcage
+                                                                                  #(x)
+                                                                                  #((top))
+                                                                                  #("i"))
+                                                                                #(ribcage
+                                                                                  (emit quasivector
+                                                                                        quasilist*
+                                                                                        quasiappend
+                                                                                        quasicons
+                                                                                        vquasi
+                                                                                        quasi)
+                                                                                  ((top)
+                                                                                   (top)
+                                                                                   (top)
+                                                                                   (top)
+                                                                                   (top)
+                                                                                   (top)
+                                                                                   (top))
+                                                                                  ("i"
+                                                                                   "i"
+                                                                                   "i"
+                                                                                   "i"
+                                                                                   "i"
+                                                                                   "i"
+                                                                                   "i"))
+                                                                                #(top-ribcage
+                                                                                  *top*
+                                                                                  #t)))
+                                                                            lexical-tmp-2900))
+                                                                    lexical-y-2899)))
+                                                            lexical-tmp-2898)
+                                                     ((lambda (lexical-tmp-2901)
+                                                        (if lexical-tmp-2901
+                                                            (apply (lambda (lexical-y-2902)
+                                                                     (lexical-k-2896
+                                                                      lexical-y-2902))
+                                                                   lexical-tmp-2901)
+                                                            ((lambda (lexical-tmp-2904)
+                                                               (if lexical-tmp-2904
+                                                                   (apply (lambda (lexical-y-2905
+                                                                                   lexical-z-2906)
+                                                                            (lexical-f-2894
+                                                                             lexical-z-2906
+                                                                             (lambda (lexical-ls-2907)
+                                                                               (lexical-k-2896
+                                                                                (append
+                                                                                 lexical-y-2905
+                                                                                 lexical-ls-2907)))))
+                                                                          lexical-tmp-2904)
+                                                                   ((lambda (lexical-else-2909)
+                                                                      ((lambda (lexical-tmp-2910)
+                                                                         ((lambda (lexical-t1-2911)
+                                                                            (list '#(syntax-object
+                                                                                     "list->vector"
+                                                                                     ((top)
+                                                                                      #(ribcage
+                                                                                        #(t1)
+                                                                                        #(("m"
+                                                                                           tmp))
+                                                                                        #("i"))
+                                                                                      #(ribcage
+                                                                                        #(else)
+                                                                                        #((top))
+                                                                                        #("i"))
+                                                                                      #(ribcage
+                                                                                        ()
+                                                                                        ()
+                                                                                        ())
+                                                                                      #(ribcage
+                                                                                        #(y k)
+                                                                                        #((top)
+                                                                                          (top))
+                                                                                        #("i"
+                                                                                          "i"))
+                                                                                      #(ribcage
+                                                                                        #(f)
+                                                                                        #((top))
+                                                                                        #("i"))
+                                                                                      #(ribcage
+                                                                                        #(_)
+                                                                                        #((top))
+                                                                                        #("i"))
+                                                                                      #(ribcage
+                                                                                        ()
+                                                                                        ()
+                                                                                        ())
+                                                                                      #(ribcage
+                                                                                        #(x)
+                                                                                        #((top))
+                                                                                        #("i"))
+                                                                                      #(ribcage
+                                                                                        (emit quasivector
+                                                                                              quasilist*
+                                                                                              quasiappend
+                                                                                              quasicons
+                                                                                              vquasi
+                                                                                              quasi)
+                                                                                        ((top)
+                                                                                         (top)
+                                                                                         (top)
+                                                                                         (top)
+                                                                                         (top)
+                                                                                         (top)
+                                                                                         (top))
+                                                                                        ("i"
+                                                                                         "i"
+                                                                                         "i"
+                                                                                         "i"
+                                                                                         "i"
+                                                                                         "i"
+                                                                                         "i"))
+                                                                                      #(top-ribcage
+                                                                                        *top*
+                                                                                        #t)))
+                                                                                  lexical-t1-2911))
+                                                                          lexical-tmp-2910))
+                                                                       lexical-x-2888))
+                                                                    lexical-tmp-2897)))
+                                                             ($syntax-dispatch
+                                                              lexical-tmp-2897
+                                                              '(#(atom "list*")
+                                                                .
+                                                                #(each+ any
+                                                                        (any)
+                                                                        ()))))))
+                                                      ($syntax-dispatch
+                                                       lexical-tmp-2897
+                                                       '(#(atom "list")
+                                                         .
+                                                         each-any)))))
+                                               ($syntax-dispatch
+                                                lexical-tmp-2897
+                                                '(#(atom "quote") each-any))))
+                                            lexical-y-2895))))
+                                 lexical-f-2894)
+                               lexical-x-2888
+                               (lambda (lexical-ls-2912)
+                                 ((lambda (lexical-tmp-2913)
+                                    ((lambda (lexical-tmp-2914)
+                                       (if lexical-tmp-2914
+                                           (apply (lambda (lexical-t2-2915)
+                                                    (cons '#(syntax-object
+                                                             "vector"
+                                                             ((top)
+                                                              #(ribcage
+                                                                #(t2)
+                                                                #(("m" tmp))
+                                                                #("i"))
+                                                              #(ribcage
+                                                                ()
+                                                                ()
+                                                                ())
+                                                              #(ribcage
+                                                                #(ls)
+                                                                #((top))
+                                                                #("i"))
+                                                              #(ribcage
+                                                                #(_)
+                                                                #((top))
+                                                                #("i"))
+                                                              #(ribcage
+                                                                ()
+                                                                ()
+                                                                ())
+                                                              #(ribcage
+                                                                #(x)
+                                                                #((top))
+                                                                #("i"))
+                                                              #(ribcage
+                                                                (emit quasivector
+                                                                      quasilist*
+                                                                      quasiappend
+                                                                      quasicons
+                                                                      vquasi
+                                                                      quasi)
+                                                                ((top)
+                                                                 (top)
+                                                                 (top)
+                                                                 (top)
+                                                                 (top)
+                                                                 (top)
+                                                                 (top))
+                                                                ("i"
+                                                                 "i"
+                                                                 "i"
+                                                                 "i"
+                                                                 "i"
+                                                                 "i"
+                                                                 "i"))
+                                                              #(top-ribcage
+                                                                *top*
+                                                                #t)))
+                                                          lexical-t2-2915))
+                                                  lexical-tmp-2914)
+                                           (syntax-error lexical-tmp-2913)))
+                                     ($syntax-dispatch
+                                      lexical-tmp-2913
+                                      'each-any)))
+                                  lexical-ls-2912))))
+                            lexical-tmp-2889)))
+                     ($syntax-dispatch
+                      lexical-tmp-2889
+                      '(#(atom "quote") each-any))))
+                  lexical-x-2888)))
+              (lexical-emit-2810
+               (lambda (lexical-x-2917)
+                 ((lambda (lexical-tmp-2918)
+                    ((lambda (lexical-tmp-2919)
+                       (if lexical-tmp-2919
+                           (apply (lambda (lexical-x-2920)
+                                    (list '#(syntax-object
+                                             quote
+                                             ((top)
+                                              #(ribcage #(x) #((top)) #("i"))
+                                              #(ribcage () () ())
+                                              #(ribcage #(x) #((top)) #("i"))
+                                              #(ribcage
+                                                (emit quasivector
+                                                      quasilist*
+                                                      quasiappend
+                                                      quasicons
+                                                      vquasi
+                                                      quasi)
+                                                ((top)
+                                                 (top)
+                                                 (top)
+                                                 (top)
+                                                 (top)
+                                                 (top)
+                                                 (top))
+                                                ("i" "i" "i" "i" "i" "i" "i"))
+                                              #(top-ribcage *top* #t)))
+                                          lexical-x-2920))
+                                  lexical-tmp-2919)
+                           ((lambda (lexical-tmp-2921)
+                              (if lexical-tmp-2921
+                                  (apply (lambda (lexical-x-2922)
+                                           ((lambda (lexical-tmp-2923)
+                                              ((lambda (lexical-tmp-2924)
+                                                 (if lexical-tmp-2924
+                                                     (apply (lambda (lexical-t3-2925)
+                                                              (cons '#(syntax-object
+                                                                       list
+                                                                       ((top)
+                                                                        #(ribcage
+                                                                          #(t3)
+                                                                          #(("m"
+                                                                             tmp))
+                                                                          #("i"))
+                                                                        #(ribcage
+                                                                          #(x)
+                                                                          #((top))
+                                                                          #("i"))
+                                                                        #(ribcage
+                                                                          ()
+                                                                          ()
+                                                                          ())
+                                                                        #(ribcage
+                                                                          #(x)
+                                                                          #((top))
+                                                                          #("i"))
+                                                                        #(ribcage
+                                                                          (emit quasivector
+                                                                                quasilist*
+                                                                                quasiappend
+                                                                                quasicons
+                                                                                vquasi
+                                                                                quasi)
+                                                                          ((top)
+                                                                           (top)
+                                                                           (top)
+                                                                           (top)
+                                                                           (top)
+                                                                           (top)
+                                                                           (top))
+                                                                          ("i"
+                                                                           "i"
+                                                                           "i"
+                                                                           "i"
+                                                                           "i"
+                                                                           "i"
+                                                                           "i"))
+                                                                        #(top-ribcage
+                                                                          *top*
+                                                                          #t)))
+                                                                    lexical-t3-2925))
+                                                            lexical-tmp-2924)
+                                                     (syntax-error
+                                                      lexical-tmp-2923)))
+                                               ($syntax-dispatch
+                                                lexical-tmp-2923
+                                                'each-any)))
+                                            (map lexical-emit-2810
+                                                 lexical-x-2922)))
+                                         lexical-tmp-2921)
+                                  ((lambda (lexical-tmp-2928)
+                                     (if lexical-tmp-2928
+                                         (apply (lambda (lexical-x-2929
+                                                         lexical-y-2930)
+                                                  ((letrec ((lexical-f-2931
+                                                             (lambda (lexical-x*-2932)
+                                                               (if (null? lexical-x*-2932)
+                                                                   (lexical-emit-2810
+                                                                    lexical-y-2930)
+                                                                   ((lambda (lexical-tmp-2933)
+                                                                      ((lambda (lexical-tmp-2934)
+                                                                         (if lexical-tmp-2934
+                                                                             (apply (lambda (lexical-t5-2935
+                                                                                             lexical-t4-2936)
+                                                                                      (list '#(syntax-object
+                                                                                               cons
+                                                                                               ((top)
+                                                                                                #(ribcage
+                                                                                                  #(t5 t4)
+                                                                                                  #(("m"
+                                                                                                     tmp)
+                                                                                                    ("m"
+                                                                                                     tmp))
+                                                                                                  #("i"
+                                                                                                    "i"))
+                                                                                                #(ribcage
+                                                                                                  ()
+                                                                                                  ()
+                                                                                                  ())
+                                                                                                #(ribcage
+                                                                                                  #(x*)
+                                                                                                  #((top))
+                                                                                                  #("i"))
+                                                                                                #(ribcage
+                                                                                                  #(f)
+                                                                                                  #((top))
+                                                                                                  #("i"))
+                                                                                                #(ribcage
+                                                                                                  #(x y)
+                                                                                                  #((top)
+                                                                                                    (top))
+                                                                                                  #("i"
+                                                                                                    "i"))
+                                                                                                #(ribcage
+                                                                                                  ()
+                                                                                                  ()
+                                                                                                  ())
+                                                                                                #(ribcage
+                                                                                                  #(x)
+                                                                                                  #((top))
+                                                                                                  #("i"))
+                                                                                                #(ribcage
+                                                                                                  (emit quasivector
+                                                                                                        quasilist*
+                                                                                                        quasiappend
+                                                                                                        quasicons
+                                                                                                        vquasi
+                                                                                                        quasi)
+                                                                                                  ((top)
+                                                                                                   (top)
+                                                                                                   (top)
+                                                                                                   (top)
+                                                                                                   (top)
+                                                                                                   (top)
+                                                                                                   (top))
+                                                                                                  ("i"
+                                                                                                   "i"
+                                                                                                   "i"
+                                                                                                   "i"
+                                                                                                   "i"
+                                                                                                   "i"
+                                                                                                   "i"))
+                                                                                                #(top-ribcage
+                                                                                                  *top*
+                                                                                                  #t)))
+                                                                                            lexical-t5-2935
+                                                                                            lexical-t4-2936))
+                                                                                    lexical-tmp-2934)
+                                                                             (syntax-error
+                                                                              lexical-tmp-2933)))
+                                                                       ($syntax-dispatch
+                                                                        lexical-tmp-2933
+                                                                        '(any any))))
+                                                                    (list (lexical-emit-2810
+                                                                           (car lexical-x*-2932))
+                                                                          (lexical-f-2931
+                                                                           (cdr lexical-x*-2932))))))))
+                                                     lexical-f-2931)
+                                                   lexical-x-2929))
+                                                lexical-tmp-2928)
+                                         ((lambda (lexical-tmp-2938)
+                                            (if lexical-tmp-2938
+                                                (apply (lambda (lexical-x-2939)
+                                                         ((lambda (lexical-tmp-2940)
+                                                            ((lambda (lexical-tmp-2941)
+                                                               (if lexical-tmp-2941
+                                                                   (apply (lambda (lexical-t6-2942)
+                                                                            (cons '#(syntax-object
+                                                                                     append
+                                                                                     ((top)
+                                                                                      #(ribcage
+                                                                                        #(t6)
+                                                                                        #(("m"
+                                                                                           tmp))
+                                                                                        #("i"))
+                                                                                      #(ribcage
+                                                                                        #(x)
+                                                                                        #((top))
+                                                                                        #("i"))
+                                                                                      #(ribcage
+                                                                                        ()
+                                                                                        ()
+                                                                                        ())
+                                                                                      #(ribcage
+                                                                                        #(x)
+                                                                                        #((top))
+                                                                                        #("i"))
+                                                                                      #(ribcage
+                                                                                        (emit quasivector
+                                                                                              quasilist*
+                                                                                              quasiappend
+                                                                                              quasicons
+                                                                                              vquasi
+                                                                                              quasi)
+                                                                                        ((top)
+                                                                                         (top)
+                                                                                         (top)
+                                                                                         (top)
+                                                                                         (top)
+                                                                                         (top)
+                                                                                         (top))
+                                                                                        ("i"
+                                                                                         "i"
+                                                                                         "i"
+                                                                                         "i"
+                                                                                         "i"
+                                                                                         "i"
+                                                                                         "i"))
+                                                                                      #(top-ribcage
+                                                                                        *top*
+                                                                                        #t)))
+                                                                                  lexical-t6-2942))
+                                                                          lexical-tmp-2941)
+                                                                   (syntax-error
+                                                                    lexical-tmp-2940)))
+                                                             ($syntax-dispatch
+                                                              lexical-tmp-2940
+                                                              'each-any)))
+                                                          (map lexical-emit-2810
+                                                               lexical-x-2939)))
+                                                       lexical-tmp-2938)
+                                                ((lambda (lexical-tmp-2945)
+                                                   (if lexical-tmp-2945
+                                                       (apply (lambda (lexical-x-2946)
+                                                                ((lambda (lexical-tmp-2947)
+                                                                   ((lambda (lexical-tmp-2948)
+                                                                      (if lexical-tmp-2948
+                                                                          (apply (lambda (lexical-t7-2949)
+                                                                                   (cons '#(syntax-object
+                                                                                            vector
+                                                                                            ((top)
+                                                                                             #(ribcage
+                                                                                               #(t7)
+                                                                                               #(("m"
+                                                                                                  tmp))
+                                                                                               #("i"))
+                                                                                             #(ribcage
+                                                                                               #(x)
+                                                                                               #((top))
+                                                                                               #("i"))
+                                                                                             #(ribcage
+                                                                                               ()
+                                                                                               ()
+                                                                                               ())
+                                                                                             #(ribcage
+                                                                                               #(x)
+                                                                                               #((top))
+                                                                                               #("i"))
+                                                                                             #(ribcage
+                                                                                               (emit quasivector
+                                                                                                     quasilist*
+                                                                                                     quasiappend
+                                                                                                     quasicons
+                                                                                                     vquasi
+                                                                                                     quasi)
+                                                                                               ((top)
+                                                                                                (top)
+                                                                                                (top)
+                                                                                                (top)
+                                                                                                (top)
+                                                                                                (top)
+                                                                                                (top))
+                                                                                               ("i"
+                                                                                                "i"
+                                                                                                "i"
+                                                                                                "i"
+                                                                                                "i"
+                                                                                                "i"
+                                                                                                "i"))
+                                                                                             #(top-ribcage
+                                                                                               *top*
+                                                                                               #t)))
+                                                                                         lexical-t7-2949))
+                                                                                 lexical-tmp-2948)
+                                                                          (syntax-error
+                                                                           lexical-tmp-2947)))
+                                                                    ($syntax-dispatch
+                                                                     lexical-tmp-2947
+                                                                     'each-any)))
+                                                                 (map lexical-emit-2810
+                                                                      lexical-x-2946)))
+                                                              lexical-tmp-2945)
+                                                       ((lambda (lexical-tmp-2952)
+                                                          (if lexical-tmp-2952
+                                                              (apply (lambda (lexical-x-2953)
+                                                                       ((lambda (lexical-tmp-2954)
+                                                                          ((lambda (lexical-t8-2955)
+                                                                             (list '#(syntax-object
+                                                                                      list->vector
+                                                                                      ((top)
+                                                                                       #(ribcage
+                                                                                         #(t8)
+                                                                                         #(("m"
+                                                                                            tmp))
+                                                                                         #("i"))
+                                                                                       #(ribcage
+                                                                                         #(x)
+                                                                                         #((top))
+                                                                                         #("i"))
+                                                                                       #(ribcage
+                                                                                         ()
+                                                                                         ()
+                                                                                         ())
+                                                                                       #(ribcage
+                                                                                         #(x)
+                                                                                         #((top))
+                                                                                         #("i"))
+                                                                                       #(ribcage
+                                                                                         (emit quasivector
+                                                                                               quasilist*
+                                                                                               quasiappend
+                                                                                               quasicons
+                                                                                               vquasi
+                                                                                               quasi)
+                                                                                         ((top)
+                                                                                          (top)
+                                                                                          (top)
+                                                                                          (top)
+                                                                                          (top)
+                                                                                          (top)
+                                                                                          (top))
+                                                                                         ("i"
+                                                                                          "i"
+                                                                                          "i"
+                                                                                          "i"
+                                                                                          "i"
+                                                                                          "i"
+                                                                                          "i"))
+                                                                                       #(top-ribcage
+                                                                                         *top*
+                                                                                         #t)))
+                                                                                   lexical-t8-2955))
+                                                                           lexical-tmp-2954))
+                                                                        (lexical-emit-2810
+                                                                         lexical-x-2953)))
+                                                                     lexical-tmp-2952)
+                                                              ((lambda (lexical-tmp-2956)
+                                                                 (if lexical-tmp-2956
+                                                                     (apply (lambda (lexical-x-2957)
+                                                                              lexical-x-2957)
+                                                                            lexical-tmp-2956)
+                                                                     (syntax-error
+                                                                      lexical-tmp-2918)))
+                                                               ($syntax-dispatch
+                                                                lexical-tmp-2918
+                                                                '(#(atom "value")
+                                                                  any)))))
+                                                        ($syntax-dispatch
+                                                         lexical-tmp-2918
+                                                         '(#(atom "list->vector")
+                                                           any)))))
+                                                 ($syntax-dispatch
+                                                  lexical-tmp-2918
+                                                  '(#(atom "vector")
+                                                    .
+                                                    each-any)))))
+                                          ($syntax-dispatch
+                                           lexical-tmp-2918
+                                           '(#(atom "append") . each-any)))))
+                                   ($syntax-dispatch
+                                    lexical-tmp-2918
+                                    '(#(atom "list*") . #(each+ any (any) ()))))))
+                            ($syntax-dispatch
+                             lexical-tmp-2918
+                             '(#(atom "list") . each-any)))))
+                     ($syntax-dispatch lexical-tmp-2918 '(#(atom "quote") any))))
+                  lexical-x-2917))))
+      (lambda (lexical-x-2958)
+        ((lambda (lexical-tmp-2959)
+           ((lambda (lexical-tmp-2960)
+              (if lexical-tmp-2960
+                  (apply (lambda (lexical-_-2961 lexical-e-2962)
+                           (lexical-emit-2810
+                            (lexical-quasi-2804 lexical-e-2962 '0)))
+                         lexical-tmp-2960)
+                  (syntax-error lexical-tmp-2959)))
+            ($syntax-dispatch lexical-tmp-2959 '(any any))))
+         lexical-x-2958)))))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object unquote ((top) #(ribcage #(unquote) #((top)) #(unquote))))
+ (lambda (lexical-x-2966) (syntax-error lexical-x-2966 '"misplaced"))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object
+    unquote-splicing
+    ((top) #(ribcage #(unquote-splicing) #((top)) #(unquote-splicing))))
+ (lambda (lexical-x-2967) (syntax-error lexical-x-2967 '"misplaced"))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object
+    quasisyntax
+    ((top) #(ribcage #(quasisyntax) #((top)) #(quasisyntax))))
+ (lambda (lexical-x-2968)
+   (letrec* ((lexical-qs-2969
+              (lambda (lexical-q-2971
+                       lexical-n-2972
+                       lexical-b*-2973
+                       lexical-k-2974)
+                ((lambda (lexical-tmp-2975)
+                   ((lambda (lexical-tmp-2976)
+                      (if lexical-tmp-2976
+                          (apply (lambda (lexical-d-2977)
+                                   (lexical-qs-2969
+                                    lexical-d-2977
+                                    (+ lexical-n-2972 '1)
+                                    lexical-b*-2973
+                                    (lambda (lexical-b*-2978 lexical-dnew-2979)
+                                      (lexical-k-2974
+                                       lexical-b*-2978
+                                       (if (eq? lexical-dnew-2979
+                                                lexical-d-2977)
+                                           lexical-q-2971
+                                           ((lambda (lexical-tmp-2980)
+                                              ((lambda (lexical-d-2981)
+                                                 (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)))
+                                                       lexical-d-2981))
+                                               lexical-tmp-2980))
+                                            lexical-dnew-2979))))))
+                                 lexical-tmp-2976)
+                          ((lambda (lexical-tmp-2982)
+                             (if (if lexical-tmp-2982
+                                     (apply (lambda (lexical-d-2983)
+                                              (not (= lexical-n-2972 '0)))
+                                            lexical-tmp-2982)
+                                     '#f)
+                                 (apply (lambda (lexical-d-2984)
+                                          (lexical-qs-2969
+                                           lexical-d-2984
+                                           (- lexical-n-2972 '1)
+                                           lexical-b*-2973
+                                           (lambda (lexical-b*-2985
+                                                    lexical-dnew-2986)
+                                             (lexical-k-2974
+                                              lexical-b*-2985
+                                              (if (eq? lexical-dnew-2986
+                                                       lexical-d-2984)
+                                                  lexical-q-2971
+                                                  ((lambda (lexical-tmp-2987)
+                                                     ((lambda (lexical-d-2988)
+                                                        (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)))
+                                                              lexical-d-2988))
+                                                      lexical-tmp-2987))
+                                                   lexical-dnew-2986))))))
+                                        lexical-tmp-2982)
+                                 ((lambda (lexical-tmp-2989)
+                                    (if (if lexical-tmp-2989
+                                            (apply (lambda (lexical-d-2990)
+                                                     (not (= lexical-n-2972 '0)))
+                                                   lexical-tmp-2989)
+                                            '#f)
+                                        (apply (lambda (lexical-d-2991)
+                                                 (lexical-qs-2969
+                                                  lexical-d-2991
+                                                  (- lexical-n-2972 '1)
+                                                  lexical-b*-2973
+                                                  (lambda (lexical-b*-2992
+                                                           lexical-dnew-2993)
+                                                    (lexical-k-2974
+                                                     lexical-b*-2992
+                                                     (if (eq? lexical-dnew-2993
+                                                              lexical-d-2991)
+                                                         lexical-q-2971
+                                                         ((lambda (lexical-tmp-2994)
+                                                            ((lambda (lexical-d-2995)
+                                                               (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)))
+                                                                     lexical-d-2995))
+                                                             lexical-tmp-2994))
+                                                          lexical-dnew-2993))))))
+                                               lexical-tmp-2989)
+                                        ((lambda (lexical-tmp-2996)
+                                           (if (if lexical-tmp-2996
+                                                   (apply (lambda (lexical-q-2997)
+                                                            (= lexical-n-2972
+                                                               '0))
+                                                          lexical-tmp-2996)
+                                                   '#f)
+                                               (apply (lambda (lexical-q-2998)
+                                                        ((lambda (lexical-tmp-2999)
+                                                           ((lambda (lexical-tmp-3000)
+                                                              (if lexical-tmp-3000
+                                                                  (apply (lambda (lexical-t-3001)
+                                                                           (lexical-k-2974
+                                                                            (cons (list lexical-t-3001
+                                                                                        lexical-q-2998)
+                                                                                  lexical-b*-2973)
+                                                                            lexical-t-3001))
+                                                                         lexical-tmp-3000)
+                                                                  (syntax-error
+                                                                   lexical-tmp-2999)))
+                                                            ($syntax-dispatch
+                                                             lexical-tmp-2999
+                                                             '(any))))
+                                                         (generate-temporaries
+                                                          (list lexical-q-2998))))
+                                                      lexical-tmp-2996)
+                                               ((lambda (lexical-tmp-3002)
+                                                  (if (if lexical-tmp-3002
+                                                          (apply (lambda (lexical-q-3003
+                                                                          lexical-d-3004)
+                                                                   (= lexical-n-2972
+                                                                      '0))
+                                                                 lexical-tmp-3002)
+                                                          '#f)
+                                                      (apply (lambda (lexical-q-3005
+                                                                      lexical-d-3006)
+                                                               (lexical-qs-2969
+                                                                lexical-d-3006
+                                                                lexical-n-2972
+                                                                lexical-b*-2973
+                                                                (lambda (lexical-b*-3007
+                                                                         lexical-dnew-3008)
+                                                                  ((lambda (lexical-tmp-3009)
+                                                                     ((lambda (lexical-tmp-3010)
+                                                                        (if lexical-tmp-3010
+                                                                            (apply (lambda (lexical-t-3011)
+                                                                                     (lexical-k-2974
+                                                                                      (append
+                                                                                       (map list
+                                                                                            lexical-t-3011
+                                                                                            lexical-q-3005)
+                                                                                       lexical-b*-3007)
+                                                                                      ((lambda (lexical-tmp-3014)
+                                                                                         ((lambda (lexical-d-3015)
+                                                                                            (append
+                                                                                             lexical-t-3011
+                                                                                             lexical-d-3015))
+                                                                                          lexical-tmp-3014))
+                                                                                       lexical-dnew-3008)))
+                                                                                   lexical-tmp-3010)
+                                                                            (syntax-error
+                                                                             lexical-tmp-3009)))
+                                                                      ($syntax-dispatch
+                                                                       lexical-tmp-3009
+                                                                       'each-any)))
+                                                                   (generate-temporaries
+                                                                    lexical-q-3005)))))
+                                                             lexical-tmp-3002)
+                                                      ((lambda (lexical-tmp-3018)
+                                                         (if (if lexical-tmp-3018
+                                                                 (apply (lambda (lexical-q-3019
+                                                                                 lexical-d-3020)
+                                                                          (= lexical-n-2972
+                                                                             '0))
+                                                                        lexical-tmp-3018)
+                                                                 '#f)
+                                                             (apply (lambda (lexical-q-3021
+                                                                             lexical-d-3022)
+                                                                      (lexical-qs-2969
+                                                                       lexical-d-3022
+                                                                       lexical-n-2972
+                                                                       lexical-b*-2973
+                                                                       (lambda (lexical-b*-3023
+                                                                                lexical-dnew-3024)
+                                                                         ((lambda (lexical-tmp-3025)
+                                                                            ((lambda (lexical-tmp-3026)
+                                                                               (if lexical-tmp-3026
+                                                                                   (apply (lambda (lexical-t-3027)
+                                                                                            (lexical-k-2974
+                                                                                             (append
+                                                                                              (map (lambda (lexical-tmp-3029
+                                                                                                            lexical-tmp-3028)
+                                                                                                     (list (cons lexical-tmp-3028
+                                                                                                                 '(#(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)))))
+                                                                                                           lexical-tmp-3029))
+                                                                                                   lexical-q-3021
+                                                                                                   lexical-t-3027)
+                                                                                              lexical-b*-3023)
+                                                                                             ((lambda (lexical-tmp-3030)
+                                                                                                ((lambda (lexical-tmp-3031)
+                                                                                                   (if lexical-tmp-3031
+                                                                                                       (apply (lambda (lexical-m-3032)
+                                                                                                                ((lambda (lexical-tmp-3033)
+                                                                                                                   ((lambda (lexical-d-3034)
+                                                                                                                      (append
+                                                                                                                       (apply append
+                                                                                                                              lexical-m-3032)
+                                                                                                                       lexical-d-3034))
+                                                                                                                    lexical-tmp-3033))
+                                                                                                                 lexical-dnew-3024))
+                                                                                                              lexical-tmp-3031)
+                                                                                                       (syntax-error
+                                                                                                        lexical-tmp-3030)))
+                                                                                                 ($syntax-dispatch
+                                                                                                  lexical-tmp-3030
+                                                                                                  '#(each each-any))))
+                                                                                              (map (lambda (lexical-tmp-3037)
+                                                                                                     (cons lexical-tmp-3037
+                                                                                                           '(#(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))))))
+                                                                                                   lexical-t-3027))))
+                                                                                          lexical-tmp-3026)
+                                                                                   (syntax-error
+                                                                                    lexical-tmp-3025)))
+                                                                             ($syntax-dispatch
+                                                                              lexical-tmp-3025
+                                                                              'each-any)))
+                                                                          (generate-temporaries
+                                                                           lexical-q-3021)))))
+                                                                    lexical-tmp-3018)
+                                                             ((lambda (lexical-tmp-3039)
+                                                                (if lexical-tmp-3039
+                                                                    (apply (lambda (lexical-a-3040
+                                                                                    lexical-d-3041)
+                                                                             (lexical-qs-2969
+                                                                              lexical-a-3040
+                                                                              lexical-n-2972
+                                                                              lexical-b*-2973
+                                                                              (lambda (lexical-b*-3042
+                                                                                       lexical-anew-3043)
+                                                                                (lexical-qs-2969
+                                                                                 lexical-d-3041
+                                                                                 lexical-n-2972
+                                                                                 lexical-b*-3042
+                                                                                 (lambda (lexical-b*-3044
+                                                                                          lexical-dnew-3045)
+                                                                                   (lexical-k-2974
+                                                                                    lexical-b*-3044
+                                                                                    (if (if (eq? lexical-anew-3043
+                                                                                                 lexical-a-3040)
+                                                                                            (eq? lexical-dnew-3045
+                                                                                                 lexical-d-3041)
+                                                                                            '#f)
+                                                                                        lexical-q-2971
+                                                                                        ((lambda (lexical-tmp-3046)
+                                                                                           ((lambda (lexical-tmp-3047)
+                                                                                              (if lexical-tmp-3047
+                                                                                                  (apply (lambda (lexical-a-3048
+                                                                                                                  lexical-d-3049)
+                                                                                                           (cons lexical-a-3048
+                                                                                                                 lexical-d-3049))
+                                                                                                         lexical-tmp-3047)
+                                                                                                  (syntax-error
+                                                                                                   lexical-tmp-3046)))
+                                                                                            ($syntax-dispatch
+                                                                                             lexical-tmp-3046
+                                                                                             '(any any))))
+                                                                                         (list lexical-anew-3043
+                                                                                               lexical-dnew-3045)))))))))
+                                                                           lexical-tmp-3039)
+                                                                    ((lambda (lexical-tmp-3050)
+                                                                       (if lexical-tmp-3050
+                                                                           (apply (lambda (lexical-x-3051)
+                                                                                    (lexical-vqs-2970
+                                                                                     lexical-x-3051
+                                                                                     lexical-n-2972
+                                                                                     lexical-b*-2973
+                                                                                     (lambda (lexical-b*-3053
+                                                                                              lexical-xnew*-3054)
+                                                                                       (lexical-k-2974
+                                                                                        lexical-b*-3053
+                                                                                        (if ((letrec ((lexical-same?-3055
+                                                                                                       (lambda (lexical-x*-3056
+                                                                                                                lexical-xnew*-3057)
+                                                                                                         (if (null? lexical-x*-3056)
+                                                                                                             (null? lexical-xnew*-3057)
+                                                                                                             (if (not (null? lexical-xnew*-3057))
+                                                                                                                 (if (eq? (car lexical-x*-3056)
+                                                                                                                          (car lexical-xnew*-3057))
+                                                                                                                     (lexical-same?-3055
+                                                                                                                      (cdr lexical-x*-3056)
+                                                                                                                      (cdr lexical-xnew*-3057))
+                                                                                                                     '#f)
+                                                                                                                 '#f)))))
+                                                                                               lexical-same?-3055)
+                                                                                             lexical-x-3051
+                                                                                             lexical-xnew*-3054)
+                                                                                            lexical-q-2971
+                                                                                            ((lambda (lexical-tmp-3059)
+                                                                                               ((lambda (lexical-tmp-3060)
+                                                                                                  (if lexical-tmp-3060
+                                                                                                      (apply (lambda (lexical-x-3061)
+                                                                                                               (list->vector
+                                                                                                                lexical-x-3061))
+                                                                                                             lexical-tmp-3060)
+                                                                                                      (syntax-error
+                                                                                                       lexical-tmp-3059)))
+                                                                                                ($syntax-dispatch
+                                                                                                 lexical-tmp-3059
+                                                                                                 'each-any)))
+                                                                                             lexical-xnew*-3054))))))
+                                                                                  lexical-tmp-3050)
+                                                                           ((lambda (lexical-_-3063)
+                                                                              (lexical-k-2974
+                                                                               lexical-b*-2973
+                                                                               lexical-q-2971))
+                                                                            lexical-tmp-2975)))
+                                                                     ($syntax-dispatch
+                                                                      lexical-tmp-2975
+                                                                      '#(vector
+                                                                         each-any)))))
+                                                              ($syntax-dispatch
+                                                               lexical-tmp-2975
+                                                               '(any . any)))))
+                                                       ($syntax-dispatch
+                                                        lexical-tmp-2975
+                                                        '((#(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
+                                                 lexical-tmp-2975
+                                                 '((#(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
+                                          lexical-tmp-2975
+                                          '(#(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
+                                   lexical-tmp-2975
+                                   '(#(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
+                            lexical-tmp-2975
+                            '(#(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
+                     lexical-tmp-2975
+                     '(#(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))))
+                 lexical-q-2971)))
+             (lexical-vqs-2970
+              (lambda (lexical-x*-3064
+                       lexical-n-3065
+                       lexical-b*-3066
+                       lexical-k-3067)
+                (if (null? lexical-x*-3064)
+                    (lexical-k-3067 lexical-b*-3066 '())
+                    (lexical-vqs-2970
+                     (cdr lexical-x*-3064)
+                     lexical-n-3065
+                     lexical-b*-3066
+                     (lambda (lexical-b*-3068 lexical-xnew*-3069)
+                       ((lambda (lexical-tmp-3070)
+                          ((lambda (lexical-tmp-3071)
+                             (if (if lexical-tmp-3071
+                                     (apply (lambda (lexical-q-3072)
+                                              (= lexical-n-3065 '0))
+                                            lexical-tmp-3071)
+                                     '#f)
+                                 (apply (lambda (lexical-q-3073)
+                                          ((lambda (lexical-tmp-3074)
+                                             ((lambda (lexical-tmp-3075)
+                                                (if lexical-tmp-3075
+                                                    (apply (lambda (lexical-t-3076)
+                                                             (lexical-k-3067
+                                                              (append
+                                                               (map list
+                                                                    lexical-t-3076
+                                                                    lexical-q-3073)
+                                                               lexical-b*-3068)
+                                                              (append
+                                                               lexical-t-3076
+                                                               lexical-xnew*-3069)))
+                                                           lexical-tmp-3075)
+                                                    (syntax-error
+                                                     lexical-tmp-3074)))
+                                              ($syntax-dispatch
+                                               lexical-tmp-3074
+                                               'each-any)))
+                                           (generate-temporaries
+                                            lexical-q-3073)))
+                                        lexical-tmp-3071)
+                                 ((lambda (lexical-tmp-3081)
+                                    (if (if lexical-tmp-3081
+                                            (apply (lambda (lexical-q-3082)
+                                                     (= lexical-n-3065 '0))
+                                                   lexical-tmp-3081)
+                                            '#f)
+                                        (apply (lambda (lexical-q-3083)
+                                                 ((lambda (lexical-tmp-3084)
+                                                    ((lambda (lexical-tmp-3085)
+                                                       (if lexical-tmp-3085
+                                                           (apply (lambda (lexical-t-3086)
+                                                                    (lexical-k-3067
+                                                                     (append
+                                                                      (map (lambda (lexical-tmp-3088
+                                                                                    lexical-tmp-3087)
+                                                                             (list (cons lexical-tmp-3087
+                                                                                         '(#(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)))))
+                                                                                   lexical-tmp-3088))
+                                                                           lexical-q-3083
+                                                                           lexical-t-3086)
+                                                                      lexical-b*-3068)
+                                                                     ((lambda (lexical-tmp-3089)
+                                                                        ((lambda (lexical-tmp-3090)
+                                                                           (if lexical-tmp-3090
+                                                                               (apply (lambda (lexical-m-3091)
+                                                                                        (append
+                                                                                         (apply append
+                                                                                                lexical-m-3091)
+                                                                                         lexical-xnew*-3069))
+                                                                                      lexical-tmp-3090)
+                                                                               (syntax-error
+                                                                                lexical-tmp-3089)))
+                                                                         ($syntax-dispatch
+                                                                          lexical-tmp-3089
+                                                                          '#(each each-any))))
+                                                                      (map (lambda (lexical-tmp-3094)
+                                                                             (cons lexical-tmp-3094
+                                                                                   '(#(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))))))
+                                                                           lexical-t-3086))))
+                                                                  lexical-tmp-3085)
+                                                           (syntax-error
+                                                            lexical-tmp-3084)))
+                                                     ($syntax-dispatch
+                                                      lexical-tmp-3084
+                                                      'each-any)))
+                                                  (generate-temporaries
+                                                   lexical-q-3083)))
+                                               lexical-tmp-3081)
+                                        ((lambda (lexical-_-3096)
+                                           (lexical-qs-2969
+                                            (car lexical-x*-3064)
+                                            lexical-n-3065
+                                            lexical-b*-3068
+                                            (lambda (lexical-b*-3097
+                                                     lexical-xnew-3098)
+                                              (lexical-k-3067
+                                               lexical-b*-3097
+                                               (cons lexical-xnew-3098
+                                                     lexical-xnew*-3069)))))
+                                         lexical-tmp-3070)))
+                                  ($syntax-dispatch
+                                   lexical-tmp-3070
+                                   '(#(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
+                            lexical-tmp-3070
+                            '(#(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))))
+                        (car lexical-x*-3064))))))))
+     ((lambda (lexical-tmp-3099)
+        ((lambda (lexical-tmp-3100)
+           (if lexical-tmp-3100
+               (apply (lambda (lexical-_-3101 lexical-x-3102)
+                        (lexical-qs-2969
+                         lexical-x-3102
+                         '0
+                         '()
+                         (lambda (lexical-b*-3103 lexical-xnew-3104)
+                           (if (eq? lexical-xnew-3104 lexical-x-3102)
+                               (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)))
+                                     lexical-x-3102)
+                               ((lambda (lexical-tmp-3105)
+                                  ((lambda (lexical-tmp-3106)
+                                     (if lexical-tmp-3106
+                                         (apply (lambda (lexical-b-3107
+                                                         lexical-x-3108)
+                                                  (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)))
+                                                        lexical-b-3107
+                                                        (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)))
+                                                              lexical-x-3108)))
+                                                lexical-tmp-3106)
+                                         (syntax-error lexical-tmp-3105)))
+                                   ($syntax-dispatch
+                                    lexical-tmp-3105
+                                    '(each-any any))))
+                                (list lexical-b*-3103 lexical-xnew-3104))))))
+                      lexical-tmp-3100)
+               (syntax-error lexical-tmp-3099)))
+         ($syntax-dispatch lexical-tmp-3099 '(any any))))
+      lexical-x-2968)))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object unsyntax ((top) #(ribcage #(unsyntax) #((top)) #(unsyntax))))
+ (lambda (lexical-x-3111) (syntax-error lexical-x-3111 '"misplaced"))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object
+    unsyntax-splicing
+    ((top) #(ribcage #(unsyntax-splicing) #((top)) #(unsyntax-splicing))))
+ (lambda (lexical-x-3112) (syntax-error lexical-x-3112 '"misplaced"))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object include ((top) #(ribcage #(include) #((top)) #(include))))
+ (lambda (lexical-x-3113)
+   (letrec* ((lexical-read-file-3114
+              (lambda (lexical-fn-3115 lexical-k-3116)
+                ((lambda (lexical-p-3117)
+                   ((letrec ((lexical-f-3118
+                              (lambda ()
+                                ((lambda (lexical-x-3119)
+                                   (if (eof-object? lexical-x-3119)
+                                       (begin
+                                         (close-input-port lexical-p-3117)
+                                         '())
+                                       (cons (datum->syntax-object
+                                              lexical-k-3116
+                                              lexical-x-3119)
+                                             (lexical-f-3118))))
+                                 (read lexical-p-3117)))))
+                      lexical-f-3118)))
+                 (open-input-file lexical-fn-3115)))))
+     ((lambda (lexical-tmp-3120)
+        ((lambda (lexical-tmp-3121)
+           (if lexical-tmp-3121
+               (apply (lambda (lexical-k-3122 lexical-filename-3123)
+                        ((lambda (lexical-fn-3124)
+                           ((lambda (lexical-tmp-3125)
+                              ((lambda (lexical-tmp-3126)
+                                 (if lexical-tmp-3126
+                                     (apply (lambda (lexical-exp-3127)
+                                              (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)))
+                                                    lexical-exp-3127))
+                                            lexical-tmp-3126)
+                                     (syntax-error lexical-tmp-3125)))
+                               ($syntax-dispatch lexical-tmp-3125 'each-any)))
+                            (lexical-read-file-3114
+                             lexical-fn-3124
+                             lexical-k-3122)))
+                         (syntax-object->datum lexical-filename-3123)))
+                      lexical-tmp-3121)
+               (syntax-error lexical-tmp-3120)))
+         ($syntax-dispatch lexical-tmp-3120 '(any any))))
+      lexical-x-3113)))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object case ((top) #(ribcage #(case) #((top)) #(case))))
+ (lambda (lexical-x-3130)
+   ((lambda (lexical-tmp-3131)
+      ((lambda (lexical-tmp-3132)
+         (if lexical-tmp-3132
+             (apply (lambda (lexical-_-3133
+                             lexical-e-3134
+                             lexical-m1-3135
+                             lexical-m2-3136)
+                      ((lambda (lexical-tmp-3137)
+                         ((lambda (lexical-body-3138)
+                            (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)))
+                                              lexical-e-3134))
+                                  lexical-body-3138))
+                          lexical-tmp-3137))
+                       ((letrec ((lexical-f-3139
+                                  (lambda (lexical-clause-3140
+                                           lexical-clauses-3141)
+                                    (if (null? lexical-clauses-3141)
+                                        ((lambda (lexical-tmp-3142)
+                                           ((lambda (lexical-tmp-3143)
+                                              (if lexical-tmp-3143
+                                                  (apply (lambda (lexical-e1-3144
+                                                                  lexical-e2-3145)
+                                                           (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 lexical-e1-3144
+                                                                       lexical-e2-3145)))
+                                                         lexical-tmp-3143)
+                                                  ((lambda (lexical-tmp-3147)
+                                                     (if lexical-tmp-3147
+                                                         (apply (lambda (lexical-k-3148
+                                                                         lexical-e1-3149
+                                                                         lexical-e2-3150)
+                                                                  (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)))
+                                                                                    lexical-k-3148))
+                                                                        (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 lexical-e1-3149
+                                                                                    lexical-e2-3150))))
+                                                                lexical-tmp-3147)
+                                                         ((lambda (lexical-_-3153)
+                                                            (syntax-error
+                                                             lexical-x-3130))
+                                                          lexical-tmp-3142)))
+                                                   ($syntax-dispatch
+                                                    lexical-tmp-3142
+                                                    '(each-any any . each-any)))))
+                                            ($syntax-dispatch
+                                             lexical-tmp-3142
+                                             '(#(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))))
+                                         lexical-clause-3140)
+                                        ((lambda (lexical-tmp-3154)
+                                           ((lambda (lexical-rest-3155)
+                                              ((lambda (lexical-tmp-3156)
+                                                 ((lambda (lexical-tmp-3157)
+                                                    (if lexical-tmp-3157
+                                                        (apply (lambda (lexical-k-3158
+                                                                        lexical-e1-3159
+                                                                        lexical-e2-3160)
+                                                                 (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)))
+                                                                                   lexical-k-3158))
+                                                                       (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 lexical-e1-3159
+                                                                                   lexical-e2-3160))
+                                                                       lexical-rest-3155))
+                                                               lexical-tmp-3157)
+                                                        ((lambda (lexical-_-3163)
+                                                           (syntax-error
+                                                            lexical-x-3130))
+                                                         lexical-tmp-3156)))
+                                                  ($syntax-dispatch
+                                                   lexical-tmp-3156
+                                                   '(each-any any . each-any))))
+                                               lexical-clause-3140))
+                                            lexical-tmp-3154))
+                                         (lexical-f-3139
+                                          (car lexical-clauses-3141)
+                                          (cdr lexical-clauses-3141)))))))
+                          lexical-f-3139)
+                        lexical-m1-3135
+                        lexical-m2-3136)))
+                    lexical-tmp-3132)
+             (syntax-error lexical-tmp-3131)))
+       ($syntax-dispatch lexical-tmp-3131 '(any any any . each-any))))
+    lexical-x-3130))
+ '*top*)
+
+($sc-put-cte
+ '#(syntax-object
+    identifier-syntax
+    ((top) #(ribcage #(identifier-syntax) #((top)) #(identifier-syntax))))
+ (lambda (lexical-x-3166)
+   ((lambda (lexical-tmp-3167)
+      ((lambda (lexical-tmp-3168)
+         (if lexical-tmp-3168
+             (apply (lambda (lexical-dummy-3169 lexical-e-3170)
+                      (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? (syntax 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)))
+                                              lexical-e-3170))
+                                  (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 lexical-e-3170
+                                                    '(#(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))))))))))
+                    lexical-tmp-3168)
+             ((lambda (lexical-tmp-3171)
+                (if (if lexical-tmp-3171
+                        (apply (lambda (lexical-dummy-3172
+                                        lexical-id-3173
+                                        lexical-exp1-3174
+                                        lexical-var-3175
+                                        lexical-val-3176
+                                        lexical-exp2-3177)
+                                 (if (identifier? lexical-id-3173)
+                                     (identifier? lexical-var-3175)
+                                     '#f))
+                               lexical-tmp-3171)
+                        '#f)
+                    (apply (lambda (lexical-dummy-3178
+                                    lexical-id-3179
+                                    lexical-exp1-3180
+                                    lexical-var-3181
+                                    lexical-val-3182
+                                    lexical-exp2-3183)
+                             (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)))
+                                                           lexical-var-3181
+                                                           lexical-val-3182)
+                                                     (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)))
+                                                           lexical-exp2-3183))
+                                               (list (cons lexical-id-3179
+                                                           '(#(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 lexical-exp1-3180
+                                                                 '(#(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 lexical-id-3179
+                                                     (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)))
+                                                                 lexical-id-3179))
+                                                     (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)))
+                                                           lexical-exp1-3180))))))
+                           lexical-tmp-3171)
+                    (syntax-error lexical-tmp-3167)))
+              ($syntax-dispatch
+               lexical-tmp-3167
+               '(any (any any)
+                     ((#(free-id
+                         #(syntax-object
+                           set!
+                           ((top)
+                            #(ribcage () () ())
+                            #(ribcage #(x) #(("m" top)) #("i"))
+                            #(top-ribcage *top* #t))))
+                       any
+                       any)
+                      any))))))
+       ($syntax-dispatch lexical-tmp-3167 '(any any))))
+    lexical-x-3166))
+ '*top*)
+
diff --git a/goldfish/scheme/psyntax.ss b/goldfish/scheme/psyntax.ss
new file mode 100644
index 000000000..1e7481a19
--- /dev/null
+++ b/goldfish/scheme/psyntax.ss
@@ -0,0 +1,4301 @@
+;;; Portable implementation of syntax-case
+;;; Extracted from Chez Scheme Version 7.3 (Feb 26, 2007)
+;;; 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
+           (+ (length (syntax (id1 ...))) 1))
+          ((index ...)
+           (let f ((i 1) (ids (syntax (id1 ...))))
+              (if (null? ids)
+                  '()
+                  (cons i (f (+ i 1) (cdr ids)))))))
+         (syntax (begin
+                   (define constructor
+                     (lambda (id1 ...)
+                       (vector 'name id1 ... )))
+                   (define predicate
+                     (lambda (x)
+                       (and (vector? x)
+                            (= (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))
+
+; 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 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 update-import-binding!
+  (lambda (symbol token p)
+    (let ((x (p (get-import-binding symbol token))))
+      (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 gensyms 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))))))))
+)
+
+
+
+;;; 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))))
+
+(define-syntax build-global-reference
+  (syntax-rules ()
+    ((_ ae var)
+     var)))
+
+(define-syntax build-global-assignment
+  (syntax-rules ()
+    ((_ ae var exp)
+     `(set! ,var ,exp))))
+
+(define-syntax build-global-definition
+  (syntax-rules ()
+    ((_ ae var exp)
+     `(define ,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)))
+
+(define-syntax build-lambda
+  (syntax-rules ()
+    ((_ ae vars exp)
+     `(lambda ,vars ,exp))))
+
+(define built-lambda?
+  (lambda (x)
+    (and (pair? x) (eq? (car x) 'lambda))))
+
+(define-syntax build-primref
+  (syntax-rules ()
+    ((_ ae name) name)
+    ((_ ae level name) name)))
+
+(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) (number? 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 (integer? n) (exact? n) (>= 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 tmp-wrap (identifier-syntax '((tmp)))) ; for generate-temporaries
+
+(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)))
+            (update-import-binding! sym token
+              (lambda (old-binding)
+                (let ((x (weed marks old-binding)))
+                  (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
+          ((> n1 n2) (cons (car m1) (f (- 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))
+           ;; lexical / global
+           (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 (= (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)))
+               (id.label (id-var-name id empty-wrap)))
+           (cond
+             ((interface-token iface) =>
+              (lambda (token)
+                (let ((found-label (lookup-import-binding-name id.sym id.marks token iface.new-marks)))
+                  (if (and found-label
+                           (not (eq? found-label id.label)))
+                      (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)))
+                             (*id.label (id-var-name *id empty-wrap)))
+                         (if (and (help-bound-id=? *id.sym *id.marks id.sym id.marks)
+                                  (not (eq? *id.label id.label)))
+                             (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))
+                          (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 (<= (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
+
+(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 '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 (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))))
+          ((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))))))
+
+
+(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))))))
+
+
+
+(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 (>= 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 (generate-id (id-sym-name mid)))))
+        (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.
+
+(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)))))))
+
+
+
+(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)))))))
+
+(set! environment?
+  (lambda (x)
+    (env? x)))
+
+
+
+(set! interaction-environment
+  (let ((e ($make-environment '*top* #t)))
+    (lambda () e)))
+
+(set! identifier?
+  (lambda (x)
+    (nonsymbol-id? x)))
+
+(set! datum->syntax-object
+  (lambda (id datum)
+    (arg-check nonsymbol-id? id 'datum->syntax-object)
+    (make-syntax-object
+      datum
+      (syntax-object-wrap id))))
+
+(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))))))
+
+(set! syntax->vector
+  (lambda (v)
+    (syntax-case v ()
+      (#(x ...) (apply vector (syntax->list #'(x ...))))
+      (_ (error 'syntax->vector "invalid argument ~s" v)))))
+
+(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)))
+
+(set! generate-temporaries
+  (let ((n 0))
+    (lambda (ls)
+      (arg-check list? ls 'generate-temporaries)
+      (map (lambda (x)
+             (set! n (+ n 1))
+             (wrap
+              ; unique name to distinguish from other temporaries
+               (string->symbol (string-append "t" (number->string n)))
+              ; unique mark (in tmp-wrap) to distinguish from non-temporaries
+               tmp-wrap))
+           ls))))
+  
+(set! free-identifier=?
+   (lambda (x y)
+      (arg-check nonsymbol-id? x 'free-identifier=?)
+      (arg-check nonsymbol-id? y 'free-identifier=?)
+      (free-id=? x y)))
+
+(set! bound-identifier=?
+   (lambda (x y)
+      (arg-check nonsymbol-id? x 'bound-identifier=?)
+      (arg-check nonsymbol-id? y 'bound-identifier=?)
+      (bound-id=? x y)))
+
+(set! literal-identifier=?
+  (lambda (x y)
+    (arg-check nonsymbol-id? x 'literal-identifier=?)
+    (arg-check nonsymbol-id? y 'literal-identifier=?)
+    (literal-id=? x y)))
+
+(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)))))
+
+(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
+  (let ()
+    (define (quasi p lev)
+      (syntax-case p (unquote quasiquote)
+        ((unquote p)
+         (if (= lev 0)
+             #'("value" p)
+             (quasicons #'("quote" unquote) (quasi #'(p) (- lev 1)))))
+        ((quasiquote p) (quasicons #'("quote" quasiquote) (quasi #'(p) (+ lev 1))))
+        ((p . q)
+         (syntax-case #'p (unquote unquote-splicing)
+           ((unquote p ...)
+            (if (= lev 0)
+                (quasilist* #'(("value" p) ...) (quasi #'q lev))
+                (quasicons
+                  (quasicons #'("quote" unquote) (quasi #'(p ...) (- lev 1)))
+                  (quasi #'q lev))))
+           ((unquote-splicing p ...)
+            (if (= lev 0)
+                (quasiappend #'(("value" p) ...) (quasi #'q lev))
+                (quasicons
+                  (quasicons #'("quote" unquote-splicing) (quasi #'(p ...) (- lev 1)))
+                  (quasi #'q lev))))
+           (_ (quasicons (quasi #'p lev) (quasi #'q lev)))))
+        (#(x ...) (quasivector (vquasi #'(x ...) lev)))
+        (p #'("quote" p))))
+    (define (vquasi p lev)
+      (syntax-case p ()
+        ((p . q)
+         (syntax-case #'p (unquote unquote-splicing)
+           ((unquote p ...)
+            (if (= lev 0)
+                (quasilist* #'(("value" p) ...) (vquasi #'q lev))
+                (quasicons
+                  (quasicons #'("quote" unquote) (quasi #'(p ...) (- lev 1)))
+                  (vquasi #'q lev))))
+           ((unquote-splicing p ...)
+            (if (= lev 0)
+                (quasiappend #'(("value" p) ...) (vquasi #'q lev))
+                (quasicons
+                  (quasicons
+                    #'("quote" unquote-splicing)
+                    (quasi #'(p ...) (- lev 1)))
+                  (vquasi #'q lev))))
+           (_ (quasicons (quasi #'p lev) (vquasi #'q lev)))))
+        (() #'("quote" ()))))
+    (define (quasicons x y)
+      (with-syntax ((x x) (y y))
+        (syntax-case #'y ()
+          (("quote" dy)
+           (syntax-case #'x ()
+             (("quote" dx) #'("quote" (dx . dy)))
+             (_ (if (null? #'dy) #'("list" x) #'("list*" x y)))))
+          (("list" . stuff) #'("list" x . stuff))
+          (("list*" . stuff) #'("list*" x . stuff))
+          (_ #'("list*" x y)))))
+    (define (quasiappend x y)
+      (syntax-case y ()
+        (("quote" ())
+         (cond
+           ((null? x) #'("quote" ()))
+           ((null? (cdr x)) (car x))
+           (else (with-syntax (((p ...) x)) #'("append" p ...)))))
+        (_
+         (cond
+           ((null? x) y)
+           (else (with-syntax (((p ...) x) (y y)) #'("append" p ... y)))))))
+    (define (quasilist* x y)
+      (let f ((x x))
+        (if (null? x)
+            y
+            (quasicons (car x) (f (cdr x))))))
+    (define (quasivector x)
+      (syntax-case x ()
+        (("quote" (x ...)) #'("quote" #(x ...)))
+        (_
+         (let f ((y x) (k (lambda (ls) #`("vector" #,@ls))))
+           (syntax-case y ()
+             (("quote" (y ...)) (k #'(("quote" y) ...)))
+             (("list" y ...) (k #'(y ...)))
+             (("list*" y ... z) (f #'z (lambda (ls) (k (append #'(y ...) ls)))))
+             (else #`("list->vector" #,x)))))))
+    (define (emit x)
+      (syntax-case x ()
+        (("quote" x) #''x)
+        (("list" x ...) #`(list #,@(map emit #'(x ...))))
+      ; could emit list* for 3+ arguments if implementation supports list*
+       (("list*" x ... y)
+        (let f ((x* #'(x ...)))
+          (if (null? x*)
+              (emit #'y)
+              #`(cons #,(emit (car x*)) #,(f (cdr x*))))))
+        (("append" x ...) #`(append #,@(map emit #'(x ...))))
+        (("vector" x ...) #`(vector #,@(map emit #'(x ...))))
+        (("list->vector" x) #`(list->vector #,(emit #'x)))
+        (("value" x) #'x)))
+    (lambda (x)
+      (syntax-case x ()
+       ; convert to intermediate language, combining introduced (but not
+       ; unquoted source) quote expressions where possible and choosing
+       ; optimal construction code otherwise, then emit Scheme code
+       ; corresponding to the intermediate language forms.
+        ((_ e) (emit (quasi #'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 (+ n 1) b*
+           (lambda (b* dnew)
+             (k b*
+                (if (eq? dnew #'d)
+                    q
+                    (with-syntax ((d dnew)) #'(quasisyntax . d)))))))
+        ((unsyntax . d)
+         (not (= n 0))
+         (qs #'d (- n 1) b*
+           (lambda (b* dnew)
+             (k b*
+                (if (eq? dnew #'d)
+                    q
+                    (with-syntax ((d dnew)) #'(unsyntax . d)))))))
+        ((unsyntax-splicing . d)
+         (not (= n 0))
+         (qs #'d (- n 1) b*
+           (lambda (b* dnew)
+             (k b*
+                (if (eq? dnew #'d)
+                    q
+                    (with-syntax ((d dnew)) #'(unsyntax-splicing . d)))))))
+        ((unsyntax q)
+         (= n 0)
+         (with-syntax (((t) (generate-temporaries #'(q))))
+           (k (cons #'(t q) b*) #'t)))
+        (((unsyntax q ...) . d)
+         (= 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)
+         (= 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 ...)
+                 (= n 0)
+                 (with-syntax (((t ...) (generate-temporaries #'(q ...))))
+                   (k (append #'((t q) ...) b*)
+                      (append #'(t ...) xnew*))))
+                ((unsyntax-splicing q ...)
+                 (= 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))))))))
+
diff --git a/goldfish/scheme/r7rs-small.scm b/goldfish/scheme/r7rs-small.scm
new file mode 100644
index 000000000..13bc5eace
--- /dev/null
+++ b/goldfish/scheme/r7rs-small.scm
@@ -0,0 +1,201 @@
+(define (identity x) x)
+
+(define (string-join lst . opt)
+  (let ((delim (if (null? opt) " " (car opt))))
+    (if (null? lst)
+        ""
+        (let loop ((l (cdr lst)) (acc (car lst)))
+          (if (null? l)
+              acc
+              (loop (cdr l) (string-append acc delim (car l))))))))
+
+(define (file-exists? path)
+  (if (string? path)
+    (if (not (g_access path 0)) ; F_OK
+      #f
+      (if (g_access path 1) ; R_OK
+          #t
+          (error 'permission-error (string-append "No permission: " path))))
+    (error 'type-error "(file-exists? path): path should be string")))
+
+(define (hash-table-ref/default ht key default)
+  (or (hash-table-ref ht key)
+      (if (procedure? default)
+          (default)
+          default)))
+
+;;; ========== 辅助函数（需在宏定义前定义）==========
+;; 将库名列表转换为点分隔符号，如 '(scheme base) -> 'scheme.base
+(define (library-name->symbol lib-name)
+  (string->symbol
+   (string-join (map (lambda (x)
+                       (cond ((symbol? x) (symbol->string x))
+                             ((number? x) (number->string x))
+                             (else (error "Invalid library name component" x))))
+                     lib-name)
+                ".")))
+
+;; 库名转候选文件名列表（用于查找文件）
+(define (library-name->filenames lib-name)
+  (let ((base (string-join (map (lambda (x)
+                                   (cond ((symbol? x) (symbol->string x))
+                                         ((number? x) (number->string x))
+                                         (else (error "Invalid library name component" x))))
+                                lib-name)
+                           "/")))
+    (list (string-append base ".scm")
+          (string-append base ".sld"))))
+
+;; 文件查找（依赖 *load-path*）
+(define (find-file-in-paths filename)
+  (let loop ((dirs *load-path*))
+    (cond ((null? dirs) #f)
+          ((file-exists? (string-append (car dirs) "/" filename))
+           (string-append (car dirs) "/" filename))
+          (else (loop (cdr dirs))))))
+
+;; 全局注册表：库名 -> 状态（#t 表示已加载，'loading 表示加载中）
+(define *library-registry* (make-hash-table))
+
+(define (load-library-by-name lib-name imp-stx)
+  (let ((status (hash-table-ref/default *library-registry* lib-name #f)))
+    (cond
+      ((eq? status #t) #t)                       ; 已加载，直接返回
+      ((eq? status 'loading)
+       (syntax-error imp-stx
+         (format #f "Circular library dependency detected: ~s" lib-name)))
+      (else
+       ;; 标记为加载中
+       (hash-table-set! *library-registry* lib-name 'loading)
+       ;; 查找文件
+       (let ((candidates (library-name->filenames lib-name)))
+         (let try ((files candidates))
+           (if (null? files)
+               (syntax-error imp-stx
+                 (format #f "Library file not found: ~s (tried ~s)" lib-name candidates))
+               (let ((full (find-file-in-paths (car files))))
+                 (if full
+                     (begin
+                       (load full)                ; 调用普通 load
+                       (hash-table-set! *library-registry* lib-name #t))
+                     (try (cdr files)))))))))))
+
+(define (expand-import-spec spec-stx ctx)
+  (define (load-lib lib-stx)
+    (let ((lib-datum (syntax->datum lib-stx)))
+      (load-library-by-name lib-datum lib-stx)))
+
+  (define (transform spec)
+    (syntax-case spec (only except prefix rename)
+      ((only lib ids ...)
+       (load-lib (syntax lib))
+       #`(only #,(transform (syntax lib)) ids ...))
+
+      ((except lib ids ...)
+       (load-lib (syntax lib))
+       #`(except #,(transform (syntax lib)) ids ...))
+
+      ((prefix lib prefix-id)
+       (load-lib (syntax lib))
+       ;; R7RS prefix -> psyntax add-prefix
+       #`(add-prefix #,(transform (syntax lib)) prefix-id))
+
+      ; ((rename lib (old new) ...) ; error: vector-ref first argument, xxx, is a xxx-type but should be a vector
+      ; ; ((rename lib old+new ...) ; works
+      ;  #'(foo))
+      ((rename lib . rest)
+       (load-lib (syntax lib))
+       (let loop ((pairs (syntax rest)) (renames '()))
+         (syntax-case pairs ()
+           (()
+            #`(rename #,(transform (syntax lib)) (unsyntax-splicing (reverse renames))))
+           (((old new) . more)
+            (loop (syntax more) (cons #'(new old) renames))))))
+
+      ((lib ...)
+       (let ((lib-stx #'(lib ...)))
+         (load-lib lib-stx)
+         (datum->syntax ctx (library-name->symbol (syntax->datum lib-stx)))))))
+  (transform spec-stx))
+
+(define-syntax define-library
+  (lambda (stx)
+    (define (parse-library-decls decls exports imports body ctx)
+      (syntax-case decls (export import begin)
+        (() (values exports imports body))
+        (((export exp* ...) . rest)
+         (parse-library-decls (syntax rest)
+                              (append #'(exp* ...) exports)
+                              imports
+                              body
+                              ctx))
+        (((import imp-spec* ...) . rest)
+         (let ((transformed
+                (map (lambda (spec)
+                       (expand-import-spec spec ctx))
+                     #'(imp-spec* ...))))
+           (parse-library-decls (syntax rest)
+                                exports
+                                (append transformed imports)
+                                body
+                                ctx)))
+        (((begin expr* ...) . rest)
+         (parse-library-decls (syntax rest)
+                              exports
+                              imports
+                              (append body #'(expr* ...))
+                              ctx))
+        (((re-export id* ...) . rest)
+         (let ((rename-exports
+                (map (lambda (id-stx)
+                       (with-syntax ((id id-stx))
+                         #'(rename id id)))
+                     #'(id* ...))))
+           (parse-library-decls #'rest
+                                (append rename-exports exports)
+                                imports
+                                body
+                                ctx)))))
+    (define (process-exports exports)
+      (let loop ((lst exports) (plain '()) (aliases '()))
+        (if (null? lst)
+            (values (reverse plain) (reverse aliases))
+            (syntax-case (car lst) (rename)
+              ((rename internal external)
+               (loop (cdr lst)
+                     (cons (syntax external) plain)
+                     (cons #'(alias external internal) aliases)))
+              (id
+               (loop (cdr lst)
+                     (cons (syntax id) plain)
+                     aliases))))))
+
+    (syntax-case stx ()
+      ((_ name decl* ...)
+       (call-with-values
+         (lambda () (parse-library-decls #'(decl* ...) '() '() '() (syntax _)))
+         (lambda (exports imports body)
+           (call-with-values
+             (lambda () (process-exports exports))
+             (lambda (plain-exports aliases)
+               (let ((lib-name (syntax->datum (syntax name)))
+                     (ctx (syntax _)))
+                 (let ((mid (datum->syntax ctx (library-name->symbol lib-name))))
+                   (with-syntax ((mid                mid)
+                                 ((exp-id* ...)      plain-exports)
+                                 ((alias* ...)       aliases)
+                                 ((import-spec* ...) (reverse imports))
+                                 ((body-expr* ...)   body))
+                     #'(module mid (exp-id* ...)
+                         (%primitive-import import-spec* ...)
+                         alias* ...
+                         body-expr* ...))))))))))))
+
+(define-syntax import
+  (lambda (stx)
+    (syntax-case stx ()
+      ((_ spec ...)
+       (with-syntax (((transformed-spec ...)
+                      (map (lambda (s) (expand-import-spec s (syntax _)))
+                           #'(spec ...))))
+         #'(%primitive-import transformed-spec ...))))))
diff --git a/goldfish/scheme/r7rs.scm b/goldfish/scheme/r7rs.scm
new file mode 100644
index 000000000..30c3abcc3
--- /dev/null
+++ b/goldfish/scheme/r7rs.scm
@@ -0,0 +1,89 @@
+; 0-clause BSD
+; Adapted from S7 Scheme's r7rs.scm
+(define-macro (define-library libname . body) ; |(lib name)| -> environment
+  `(define ,(symbol (object->string libname))
+     (with-let (sublet (unlet)
+                 (cons 'import import)
+                 (cons '*export* ())
+                 (cons 'export (define-macro (,(gensym) . names)
+                                 `(set! *export* (append ',names *export*)))))
+       ,@body
+       (apply inlet
+              (map (lambda (entry)
+                     (if (or (member (car entry) '(*export* export import))
+                             (and (pair? *export*)
+                                  (not (member (car entry) *export*))))
+                         (values)
+                         entry))
+                   (curlet))))))
+
+(unless (defined? 'r7rs-import-library-filename)
+  (define (r7rs-import-library-filename libs)
+    (when (pair? libs)
+      (let ((lib-filename (let loop ((lib (if (memq (caar libs) '(only except prefix rename))
+                                              (cadar libs)
+                                              (car libs)))
+                                     (name ""))
+                            (set! name (string-append name (symbol->string (car lib))))
+                            (if (null? (cdr lib))
+                                (string-append name ".scm")
+                                (begin
+                                  (set! name (string-append name "/"))
+                                  (loop (cdr lib) name))))))
+        (when (not (defined? (symbol (object->string (car libs)))))
+          ;(display "Loading ") (display lib-filename) (newline)
+          (load lib-filename))
+        (r7rs-import-library-filename (cdr libs))))))
+
+(define-macro (import . libs)
+  `(begin
+     (r7rs-import-library-filename ',libs)
+     (varlet (curlet)
+       ,@(map (lambda (lib)
+                (case (car lib)
+                  ((only)
+                   `((lambda (e names)
+                       (apply inlet
+                              (map (lambda (name)
+                                     (cons name (e name)))
+                                   names)))
+                     (symbol->value (symbol (object->string (cadr ',lib))))
+                     (cddr ',lib)))
+                  ((except)
+                   `((lambda (e names)
+                       (apply inlet
+                              (map (lambda (entry)
+                                     (if (member (car entry) names)
+                                         (values)
+                                         entry))
+                                   e)))
+                     (symbol->value (symbol (object->string (cadr ',lib))))
+                     (cddr ',lib)))
+                  ((prefix)
+                   `((lambda (e prefx)
+                       (apply inlet
+                              (map (lambda (entry)
+                                     (cons (string->symbol 
+                                            (string-append (symbol->string prefx) 
+                                                           (symbol->string (car entry)))) 
+                                           (cdr entry)))
+                                   e)))
+                     (symbol->value (symbol (object->string (cadr ',lib))))
+                     (caddr ',lib)))
+                  ((rename)
+                   `((lambda (e names)
+                       (apply inlet
+                              (map (lambda (entry)
+                                     (let ((info (assoc (car entry) names)))
+                                       (if info
+                                           (cons (cadr info) (cdr entry))
+                                           entry))) 
+                                   e)))
+                     (symbol->value (symbol (object->string (cadr ',lib))))
+                     (cddr ',lib)))
+                  (else
+                   `(let ((sym (symbol (object->string ',lib))))
+                      (if (not (defined? sym))
+                          (format () "~A not loaded~%" sym)
+                          (symbol->value sym))))))
+              libs))))
diff --git a/goldfish/scheme/read.scm b/goldfish/scheme/read.scm
index d4a06b0e5..47069acc6 100644
--- a/goldfish/scheme/read.scm
+++ b/goldfish/scheme/read.scm
@@ -15,7 +15,4 @@
 ;
 
 (define-library (scheme read)
-  (export read)
-  (begin
-  ) ;begin
-) ;define-library
+  (re-export read))
diff --git a/goldfish/scheme/s7-shim.scm b/goldfish/scheme/s7-shim.scm
new file mode 100644
index 000000000..201aa2af1
--- /dev/null
+++ b/goldfish/scheme/s7-shim.scm
@@ -0,0 +1,93 @@
+;; define-macro shim: converts s7's define-macro to psyntax syntax-case
+;;
+;; 策略：
+;; 1. 在编译期用 %primitive-eval 创建 transformer 函数
+;; 2. 将 transformer 存入全局 hash-table，key 为生成的唯一符号
+;; 3. 生成的 define-syntax 通过 hash-table 查找来获取 transformer
+;;
+(define *macro-transformers* (make-hash-table))
+
+(define-syntax define-macro
+  (lambda (x)
+    (syntax-case x ()
+      ((kw . _)
+       (let ((form (syntax->datum x)))
+         ;; form = (define-macro (name . args) body ...) or (define-macro name expr)
+         (if (and (pair? (cadr form))
+                  (symbol? (caadr form)))
+             ;; 带参数的宏: (define-macro (name . args) body ...)
+             (let* ((name-sym (caadr form))
+                    (args-dat (cdadr form))
+                    (body-dat (cddr form))
+                    (transformer-proc
+                      (%primitive-eval (cons 'lambda (cons args-dat body-dat))))
+                    (key (symbol->string (gensym "macro-")))
+                    (dummy (hash-table-set! *macro-transformers* key transformer-proc))
+                    (name-id (datum->syntax (syntax kw) name-sym)))
+               (with-syntax ((the-name name-id)
+                             (the-key key))
+                 (syntax
+                   (define-syntax the-name
+                     (lambda (stx)
+                       (syntax-case stx ()
+                         ((k . rest)
+                          (datum->syntax (syntax k)
+                            (apply (hash-table-ref *macro-transformers* the-key)
+                                   (syntax->datum (syntax rest))))))))))))
+             ;; 无参数的宏: (define-macro name expr)
+             (let* ((name-sym (cadr form))
+                    (expr-dat (caddr form))
+                    (transformer-proc (%primitive-eval expr-dat))
+                    (key (symbol->string (gensym "macro-")))
+                    (dummy (hash-table-set! *macro-transformers* key transformer-proc))
+                    (name-id (datum->syntax (syntax kw) name-sym)))
+               (with-syntax ((the-name name-id)
+                             (the-key key))
+                 (syntax
+                   (define-syntax the-name
+                     (lambda (stx)
+                       (syntax-case stx ()
+                         (id (identifier? (syntax id))
+                             (datum->syntax (syntax id)
+                               ((hash-table-ref *macro-transformers* the-key)))))))))))))))
+(define-syntax define-syntax-rule
+  (syntax-rules ()
+    ((_ (name . pattern) template)
+     (define-syntax name
+       (syntax-rules ()
+         ((_ . pattern) template))))))
+
+
+(define-syntax-rule (lambda* (spec ...) body ...)
+  (lambda*-specs (spec ...) () () body ...))
+
+;; 归一化
+(define-syntax lambda*-specs
+  (syntax-rules ()
+    ((_ () ((id d) ...) body ...)
+     (lambda _args
+       (lambda*-bind ((id d) ...) _args body ...)))
+    ;; 带显式默认值
+    ((_ ((x d) . rest) (acc ...) body ...)
+     (lambda*-specs rest (acc ... (x d)) body ...))
+    ;; 无默认值 → #f
+    ((_ (x . rest) (acc ...) body ...)
+     (lambda*-specs rest (acc ... (x #f)) body ...))))
+
+;; 顺序绑定
+(define-syntax lambda*-bind
+  (syntax-rules ()
+    ((_ () _args body ...)
+     (let () body ...))
+    ((_ ((x d) . more) _args body ...)
+     (let ((x (if (null? _args) d (car _args)))
+           (_rest (if (null? _args) '() (cdr _args))))
+       (lambda*-bind more _rest body ...)))))
+
+(define-syntax define*
+  (lambda (x)
+    (syntax-case x ()
+      ((_ (id . args) b0 b1 ...)
+       #'(define id (lambda* args (let () b0 b1 ...))))
+      ((_ id val) (identifier? (syntax id))
+       #'(define id val)))))
diff --git a/goldfish/scheme/write.scm b/goldfish/scheme/write.scm
index bd47f6a86..158922dda 100644
--- a/goldfish/scheme/write.scm
+++ b/goldfish/scheme/write.scm
@@ -15,13 +15,8 @@
 ;
 
 (define-library (scheme write)
-  (export display write write-shared write-simple newline write-char)
-  (begin
-
-    ; s7 does not currently expose separate built-ins for these two names.
-    (define write-simple write)
-
-    (define write-shared write)
-
-  ) ;begin
+  (re-export display write newline write-char)
+  ; s7 does not currently expose separate built-ins for these two names.
+  (export (rename write write-simple)
+          (rename write write-shared))
 ) ;define-library
diff --git a/goldfish/srfi/srfi-1.scm b/goldfish/srfi/srfi-1.scm
index 548ba73a5..abc0ca143 100644
--- a/goldfish/srfi/srfi-1.scm
+++ b/goldfish/srfi/srfi-1.scm
@@ -14,7 +14,7 @@
 (define-library (srfi srfi-1)
   (import (liii error) (liii base))
   ; SRFI 1: Constructors
-  (export circular-list iota list-copy xcons cons*)
+  (export circular-list (rename iota iota) list-copy xcons cons*)
   ; SRFI 1: Predicates
   (export circular-list? null-list? proper-list? dotted-list?)
   ; SRFI 1: Selectors
diff --git a/goldfish/srfi/srfi-117.scm b/goldfish/srfi/srfi-117.scm
index eefdb5adf..6f47dec08 100644
--- a/goldfish/srfi/srfi-117.scm
+++ b/goldfish/srfi/srfi-117.scm
@@ -44,7 +44,7 @@
     ) ;define-record-type
 
     ;;; Helper function: return the last pair of a list
-    (define (last-pair ls)
+    (define (last-pair* ls)
       (if (null? (cdr ls))
         ls
         (last-pair (cdr ls))
@@ -81,7 +81,7 @@
       (if (null? rest)
         (if (null? list-arg)
           (raw-make-list-queue '() '())
-          (raw-make-list-queue list-arg (last-pair list-arg))
+          (raw-make-list-queue list-arg (last-pair* list-arg))
         ) ;if
         (raw-make-list-queue list-arg (car rest))
       ) ;if
@@ -191,7 +191,7 @@
           (set-first! list-queue first-list)
           (if (null? first-list)
             (set-last! list-queue '())
-            (set-last! list-queue (last-pair first-list))
+            (set-last! list-queue (last-pair* first-list))
           ) ;if
         ) ;begin
         (begin
diff --git a/goldfish/srfi/srfi-125.scm b/goldfish/srfi/srfi-125.scm
index 33194387b..38ba646f1 100644
--- a/goldfish/srfi/srfi-125.scm
+++ b/goldfish/srfi/srfi-125.scm
@@ -16,10 +16,12 @@
 
 (define-library (srfi srfi-125)
   (import (srfi srfi-1) (srfi srfi-128) (liii base) (liii error))
-  (export make-hash-table hash-table hash-table-unfold alist->hash-table hash-table?
-          hash-table-contains? hash-table-empty? hash-table=? hash-table-mutable? hash-table-ref
-          hash-table-ref/default hash-table-set! hash-table-delete! hash-table-intern!
-          hash-table-update! hash-table-update!/default hash-table-pop! hash-table-clear!
+  (re-export hash-table hash-table-unfold hash-table? hash-table-mutable? hash-table-ref
+             hash-table-intern! hash-table-pop!)
+  (export make-hash-table alist->hash-table
+          hash-table-contains? hash-table-empty? hash-table=?
+          hash-table-ref/default hash-table-set! hash-table-delete!
+          hash-table-update! hash-table-update!/default hash-table-clear!
           hash-table-size hash-table-keys hash-table-values hash-table-entries hash-table-find
           hash-table-count hash-table-fold hash-table-for-each hash-table-map->list
           hash-table->alist hash-table-copy
diff --git a/goldfish/srfi/srfi-151.scm b/goldfish/srfi/srfi-151.scm
index f302961a6..7f9b01d80 100644
--- a/goldfish/srfi/srfi-151.scm
+++ b/goldfish/srfi/srfi-151.scm
@@ -45,22 +45,15 @@
 
     (define bit-count
       (typed-lambda ((i integer?))
-        (define (bit-count-positive i)
-          (let loop ((n i)
-                     (cnt 0))
-            (if (= n 0)
-                cnt
-                (loop (logand n (- n 1)) (+ cnt 1))
-            ) ;if
-          ) ;let
-        ) ;define
-
-        (cond ((zero? i) 0)
-              ((positive? i) (bit-count-positive i))
-              (else (bit-count-positive (lognot i)))
-        ) ;cond
-      ) ;typed-lambda
-    ) ;define
+        (let ((bit-count-positive
+                  (lambda (i)
+                    (let loop ((n i) (cnt 0))
+                      (if (= n 0)
+                          cnt
+                          (loop (logand n (- n 1)) (+ cnt 1)))))))
+          (cond ((zero? i) 0)
+                ((positive? i) (bit-count-positive i))
+                (else (bit-count-positive (lognot i)))))))
 
     (define (bitwise-orc1 i j)
       (bitwise-ior (bitwise-not i) j)
diff --git a/goldfish/srfi/srfi-158.scm b/goldfish/srfi/srfi-158.scm
index 65d5ed758..d8791dd23 100644
--- a/goldfish/srfi/srfi-158.scm
+++ b/goldfish/srfi/srfi-158.scm
@@ -41,61 +41,61 @@
   (export generator
           circular-generator
           make-iota-generator
-          make-range-generator
-          make-coroutine-generator
-          make-for-each-generator
-          make-unfold-generator
-
-          list->generator
-          vector->generator
-          reverse-vector->generator
-          string->generator
-          bytevector->generator
-
-          generator->list
-          generator->reverse-list
-          generator->vector
-          generator->vector!
-          generator->string
-          generator-map->list
-
-          gcons*
-          gappend
-          gflatten
-          ggroup
-          gmerge
-          gmap
-          gcombine
-          gfilter
-          gremove
-          gstate-filter
-          gtake
-          gdrop
-          gtake-while
-          gdrop-while
-          gdelete
-          gdelete-neighbor-dups
-          gindex
-          gselect
-          generator-fold
-          generator-for-each
-          generator-find
-          generator-count
-          generator-any
-          generator-every
-          generator-unfold
-
-          make-accumulator
-          list-accumulator
-          reverse-list-accumulator
-          vector-accumulator
-          reverse-vector-accumulator
-          vector-accumulator!
-          string-accumulator
-          bytevector-accumulator
-          bytevector-accumulator!
-          sum-accumulator
-          product-accumulator
+  ;         make-range-generator
+  ;         make-coroutine-generator
+  ;         make-for-each-generator
+  ;         make-unfold-generator
+  ;
+  ;         list->generator
+  ;         vector->generator
+  ;         reverse-vector->generator
+  ;         string->generator
+  ;         bytevector->generator
+  ;
+  ;         generator->list
+  ;         generator->reverse-list
+  ;         generator->vector
+  ;         generator->vector!
+  ;         generator->string
+  ;         generator-map->list
+  ;
+  ;         gcons*
+  ;         gappend
+  ;         gflatten
+  ;         ggroup
+  ;         gmerge
+  ;         gmap
+  ;         gcombine
+  ;         gfilter
+  ;         gremove
+  ;         gstate-filter
+  ;         gtake
+  ;         gdrop
+  ;         gtake-while
+  ;         gdrop-while
+  ;         gdelete
+  ;         gdelete-neighbor-dups
+  ;         gindex
+  ;         gselect
+  ;         generator-fold
+  ;         generator-for-each
+  ;         generator-find
+  ;         generator-count
+  ;         generator-any
+  ;         generator-every
+  ;         generator-unfold
+  ;
+  ;         make-accumulator
+  ;         list-accumulator
+  ;         reverse-list-accumulator
+  ;         vector-accumulator
+  ;         reverse-vector-accumulator
+  ;         vector-accumulator!
+  ;         string-accumulator
+  ;         bytevector-accumulator
+  ;         bytevector-accumulator!
+  ;         sum-accumulator
+  ;         product-accumulator
   ) ;export
 
   (begin
@@ -160,774 +160,774 @@
       ) ;case-lambda
     ) ;define
 
-    ;; make-iota
-    (define (make-iota count start step)
-      (lambda ()
-        (cond
-          ((<= count 0)
-           (eof-object)
-          ) ;
-          (else
-            (let ((result start))
-             (set! count (- count 1))
-             (set! start (+ start step))
-             result
-            ) ;let
-          ) ;else
-        ) ;cond
-      ) ;lambda
-    ) ;define
-
-
-    ;; make-range-generator
-    (define make-range-generator
-      (case-lambda ((start end) (make-range-generator start end 1))
-                   ((start) (make-infinite-range-generator start))
-                   ((start end step)
-                    (set! start (- (+ start step) step))
-                    (lambda () (if (< start end)
-                                 (let ((v start))
-                                  (set! start (+ start step))
-                                  v
-                                 ) ;let
-                                 (eof-object))
-                    ) ;lambda
-                   ) ;
-      ) ;case-lambda
-    ) ;define
-
-    (define (make-infinite-range-generator start)
-      (lambda ()
-        (let ((result start))
-         (set! start (+ start 1))
-         result
-        ) ;let
-      ) ;lambda
-    ) ;define
-
-
-
-    ;; make-coroutine-generator
-    (define (make-coroutine-generator proc)
-      (define return #f)
-      (define resume #f)
-      (define yield (lambda (v) (call/cc (lambda (r) (set! resume r) (return v)))))
-      (lambda () (call/cc (lambda (cc) (set! return cc)
-                            (if resume
-                              (resume (if #f #f))  ; void? or yield again?
-                              (begin (proc yield)
-                                     (set! resume (lambda (v) (return (eof-object))))
-                                     (return (eof-object))))
-                              ) ;begin
-                            ) ;if
-      ) ;lambda
-    ) ;define
-
-
-    ;; list->generator
-    (define (list->generator lst)
-      (lambda () (if (null? lst)
-                   (eof-object)
-                   (let ((next (car lst)))
-                     (set! lst (cdr lst))
-                     next)
-                   ) ;let
-      ) ;lambda
-    ) ;define
-
-
-    ;; vector->generator
-    (define vector->generator
-      (case-lambda ((vec) (vector->generator vec 0 (vector-length vec)))
-                   ((vec start) (vector->generator vec start (vector-length vec)))
-                   ((vec start end)
-                    (lambda () (if (>= start end)
-                                 (eof-object)
-                                 (let ((next (vector-ref vec start)))
-                                   (set! start (+ start 1))
-                                   next)
-                                 ) ;let
-                    ) ;lambda
-                   ) ;
-      ) ;case-lambda
-    ) ;define
-
-
-    ;; reverse-vector->generator
-    (define reverse-vector->generator
-      (case-lambda ((vec) (reverse-vector->generator vec 0 (vector-length vec)))
-                   ((vec start) (reverse-vector->generator vec start (vector-length vec)))
-                   ((vec start end)
-                    (lambda () (if (>= start end)
-                                 (eof-object)
-                                 (let ((next (vector-ref vec (- end 1))))
-                                   (set! end (- end 1))
-                                   next)
-                                 ) ;let
-                    ) ;lambda
-                   ) ;
-      ) ;case-lambda
-    ) ;define
-
-
-    ;; string->generator
-    (define string->generator
-      (case-lambda ((str) (string->generator str 0 (string-length str)))
-                   ((str start) (string->generator str start (string-length str)))
-                   ((str start end)
-                    (lambda () (if (>= start end)
-                                 (eof-object)
-                                 (let ((next (string-ref str start)))
-                                   (set! start (+ start 1))
-                                   next)
-                                 ) ;let
-                    ) ;lambda
-                   ) ;
-      ) ;case-lambda
-    ) ;define
-
-
-    ;; bytevector->generator
-    (define bytevector->generator
-      (case-lambda ((str) (bytevector->generator str 0 (bytevector-length str)))
-                   ((str start) (bytevector->generator str start (bytevector-length str)))
-                   ((str start end)
-                    (lambda () (if (>= start end)
-                                 (eof-object)
-                                 (let ((next (bytevector-u8-ref str start)))
-                                   (set! start (+ start 1))
-                                   next)
-                                 ) ;let
-                    ) ;lambda
-                   ) ;
-      ) ;case-lambda
-    ) ;define
-
-
-    ;; make-for-each-generator
-    ;FIXME: seems to fail test
-    (define (make-for-each-generator for-each obj)
-      (make-coroutine-generator (lambda (yield) (for-each yield obj)))
-    ) ;define
-
-
-    ;; make-unfold-generator
-    (define (make-unfold-generator stop? mapper successor seed)
-      (make-coroutine-generator (lambda (yield)
-                                  (let loop ((s seed))
-                                   (if (stop? s)
-                                     (if #f #f)
-                                     (begin (yield (mapper s))
-                                            (loop (successor s)))
-                                     ) ;begin
-                                   ) ;if
-                                  ) ;let
-      ) ;make-coroutine-generator
-    ) ;define
-
-
-    ;; gcons*
-    (define (gcons* . args)
-      (lambda () (if (null? args)
-                   (eof-object)
-                   (if (= (length args) 1)
-                     ((car args))
-                     (let ((v (car args)))
-                      (set! args (cdr args))
-                      v)
-                     ) ;let
-                   ) ;if
-      ) ;lambda
-    ) ;define
-
-
-    ;; gappend
-    (define (gappend . args)
-      (lambda () (if (null? args)
-                   (eof-object)
-                   (let loop ((v ((car args))))
-                    (if (eof-object? v)
-                      (begin (set! args (cdr args))
-                             (if (null? args)
-                               (eof-object)
-                               (loop ((car args)))
-                             ) ;if
-                      ) ;begin
-                      v)
-                    ) ;if
-                   ) ;let
-      ) ;lambda
-    ) ;define
-
-    ;; gflatten
-    (define (gflatten gen)
-      (let ((state '()))
-        (lambda ()
-          (if (null? state) (set! state (gen)))
-          (if (eof-object? state)
-            state
-            (let ((obj (car state)))
-              (set! state (cdr state))
-              obj
-            ) ;let
-          ) ;if
-        ) ;lambda
-      ) ;let
-    ) ;define
-
-    ;; ggroup
-    (define ggroup
-      (case-lambda
-        ((gen k)
-         (simple-ggroup gen k)
-        ) ;
-        ((gen k padding)
-         (padded-ggroup (simple-ggroup gen k) k padding)
-        ) ;
-      ) ;case-lambda
-    ) ;define
-
-    (define (simple-ggroup gen k)
-      (lambda ()
-        (let loop ((item (gen)) (result '()) (count (- k 1)))
-          (if (eof-object? item)
-            (if (null? result) item (reverse result))
-            (if (= count 0)
-              (reverse (cons item result))
-              (loop (gen) (cons item result) (- count 1))
-            ) ;if
-          ) ;if
-        ) ;let
-      ) ;lambda
-    ) ;define
-
-    (define (padded-ggroup gen k padding)
-      (lambda ()
-        (let ((item (gen)))
-          (if (eof-object? item)
-            item
-            (let ((len (length item)))
-              (if (= len k)
-                  item
-                  (append item (make-list (- k len) padding))
-              ) ;if
-            ) ;let
-          ) ;if
-        ) ;let
-      ) ;lambda
-    ) ;define
-
-    ;; gmerge
-    (define gmerge
-      (case-lambda
-        ((<) (error "wrong number of arguments for gmerge"))
-        ((< gen) gen)
-        ((< genleft genright)
-         (let ((left (genleft))
-               (right (genright)))
-           (lambda ()
-             (cond
-              ((and (eof-object? left) (eof-object? right))
-               left
-              ) ;
-              ((eof-object? left)
-               (let ((obj right)) (set! right (genright)) obj)
-              ) ;
-              ((eof-object? right)
-               (let ((obj left))  (set! left (genleft)) obj)
-              ) ;
-              ((< right left)
-               (let ((obj right)) (set! right (genright)) obj)
-              ) ;
-              (else
-               (let ((obj left)) (set! left (genleft)) obj)
-              ) ;else
-             ) ;cond
-           ) ;lambda
-         ) ;let
-        ) ;
-        ((< . gens)
-         (apply gmerge <
-                (let loop ((gens gens) (gs '()))
-                  (cond ((null? gens) (reverse gs))
-                        ((null? (cdr gens)) (reverse (cons (car gens) gs)))
-                        (else
-                         (loop (cddr gens)
-                               (cons (gmerge < (car gens) (cadr gens)) gs)
-                         ) ;loop
-                        ) ;else
-                  ) ;cond
-                ) ;let
-         ) ;apply
-        ) ;
-      ) ;case-lambda
-    ) ;define
-
-    ;; gmap
-    (define gmap
-      (case-lambda
-        ((proc) (error "wrong number of arguments for gmap"))
-        ((proc gen)
-         (lambda ()
-           (let ((item (gen)))
-             (if (eof-object? item) item (proc item))
-           ) ;let
-         ) ;lambda
-        ) ;
-        ((proc . gens)
-         (lambda ()
-           (let ((items (map (lambda (x) (x)) gens)))
-             (if (any eof-object? items) (eof-object) (apply proc items))
-           ) ;let
-         ) ;lambda
-        ) ;
-      ) ;case-lambda
-    ) ;define
-
-    ;; gcombine
-    (define (gcombine proc seed . gens)
-      (lambda ()
-        (define items (map (lambda (x) (x)) gens))
-        (if (any eof-object? items)
-          (eof-object)
-          (let ()
-           (define-values (value newseed) (apply proc (append items (list seed))))
-           (set! seed newseed)
-           value
-          ) ;let
-        ) ;if
-      ) ;lambda
-    ) ;define
-
-    ;; gfilter
-    (define (gfilter pred gen)
-      (lambda () (let loop ()
-                  (let ((next (gen)))
-                    (if (or (eof-object? next)
-                            (pred next))
-                      next
-                      (loop))
-                    ) ;if
-                  ) ;let
-      ) ;lambda
-    ) ;define
-
-    ;; gstate-filter
-    (define (gstate-filter proc seed gen)
-      (let ((state seed))
-        (lambda ()
-          (let loop ((item (gen)))
-            (if (eof-object? item)
-              item
-              (let-values (((yes newstate) (proc item state)))
-                (set! state newstate)
-                (if yes
-                   item
-                   (loop (gen))
-                ) ;if
-              ) ;let-values
-            ) ;if
-          ) ;let
-        ) ;lambda
-      ) ;let
-    ) ;define
-
-
-
-    ;; gremove
-    (define (gremove pred gen)
-      (gfilter (lambda (v) (not (pred v))) gen)
-    ) ;define
-
-
-
-    ;; gtake
-    (define gtake
-      (case-lambda ((gen k) (gtake gen k (eof-object)))
-                   ((gen k padding)
-                    (make-coroutine-generator (lambda (yield)
-                                                (if (> k 0)
-                                                  (let loop ((i 0) (v (gen)))
-                                                   (begin (if (eof-object? v) (yield padding) (yield v))
-                                                          (if (< (+ 1 i) k)
-                                                            (loop (+ 1 i) (gen))
-                                                            (eof-object)
-                                                          ) ;if
-                                                   ) ;begin
-                                                  ) ;let
-                                                  (eof-object))
-                                                ) ;if
-                    ) ;make-coroutine-generator
-                   ) ;
-      ) ;case-lambda
-    ) ;define
-
-
-
-    ;; gdrop
-    (define (gdrop gen k)
-      (lambda () (do () ((<= k 0)) (set! k (- k 1)) (gen))
-        (gen)
-      ) ;lambda
-    ) ;define
-
-
-
-    ;; gdrop-while
-    (define (gdrop-while pred gen)
-      (define found #f)
-      (lambda ()
-        (let loop ()
-         (let ((val (gen)))
-          (cond (found val)
-                ((and (not (eof-object? val)) (pred val)) (loop))
-                (else (set! found #t) val)
-          ) ;cond
-         ) ;let
-        ) ;let
-      ) ;lambda
-    ) ;define
-
-
-    ;; gtake-while
-    (define (gtake-while pred gen)
-      (lambda () (let ((next (gen)))
-                   (if (eof-object? next)
-                     next
-                     (if (pred next)
-                       next
-                       (begin (set! gen (generator))
-                              (gen))
-                       ) ;begin
-                     ) ;if
-                   ) ;if
-      ) ;lambda
-    ) ;define
-
-
-
-    ;; gdelete
-    (define gdelete
-      (case-lambda ((item gen) (gdelete item gen equal?))
-                   ((item gen ==)
-                    (lambda () (let loop ((v (gen)))
-                                (cond
-                                  ((eof-object? v) (eof-object))
-                                  ((== item v) (loop (gen)))
-                                  (else v))
-                                ) ;cond
-                    ) ;lambda
-                   ) ;
-      ) ;case-lambda
-    ) ;define
-
-
-
-    ;; gdelete-neighbor-dups
-    (define gdelete-neighbor-dups
-      (case-lambda ((gen)
-                    (gdelete-neighbor-dups gen equal?))
-                   ((gen ==)
-                    (define firsttime #t)
-                    (define prev #f)
-                    (lambda () (if firsttime
-                                 (begin (set! firsttime #f)
-                                        (set! prev (gen))
-                                        prev
-                                 ) ;begin
-                                 (let loop ((v (gen)))
-                                  (cond
-                                    ((eof-object? v)
-                                     v
-                                    ) ;
-                                    ((== prev v)
-                                     (loop (gen))
-                                    ) ;
-                                    (else
-                                      (set! prev v)
-                                      v)
-                                    ) ;else
-                                  ) ;cond
-                                 ) ;let
-                    ) ;lambda
-                   ) ;
-      ) ;case-lambda
-    ) ;define
-
-
-    ;; gindex
-    (define (gindex value-gen index-gen)
-      (let ((done? #f) (count 0))
-       (lambda ()
-         (if done?
-           (eof-object)
-           (let loop ((value (value-gen)) (index (index-gen)))
-            (cond
-              ((or (eof-object? value) (eof-object? index))
-               (set! done? #t)
-               (eof-object)
-              ) ;
-              ((= index count)
-               (set! count (+ count 1))
-               value
-              ) ;
-              (else
-                (set! count (+ count 1))
-                (loop (value-gen) index)
-              ) ;else
-            ) ;cond
-           ) ;let
-         ) ;if
-       ) ;lambda
-      ) ;let
-    ) ;define
-
-
-    ;; gselect
-    (define (gselect value-gen truth-gen)
-      (let ((done? #f))
-       (lambda ()
-         (if done?
-           (eof-object)
-           (let loop ((value (value-gen)) (truth (truth-gen)))
-            (cond
-              ((or (eof-object? value) (eof-object? truth))
-               (set! done? #t)
-               (eof-object)
-              ) ;
-              (truth value)
-              (else (loop (value-gen) (truth-gen)))
-            ) ;cond
-           ) ;let
-         ) ;if
-       ) ;lambda
-      ) ;let
-    ) ;define
-
-    ;; generator->list
-    (define generator->list
-      (case-lambda
-        ((gen n)
-         (generator->list (gtake gen n))
-        ) ;
-        ((gen)
-         (reverse (generator->reverse-list gen))
-        ) ;
-      ) ;case-lambda
-    ) ;define
-
-    ;; generator->reverse-list
-    (define generator->reverse-list
-      (case-lambda
-        ((gen n)
-         (generator->reverse-list (gtake gen n))
-        ) ;
-        ((gen)
-         (generator-fold cons '() gen)
-        ) ;
-      ) ;case-lambda
-    ) ;define
-
-    ;; generator->vector
-    (define generator->vector
-      (case-lambda ((gen) (list->vector (generator->list gen)))
-                   ((gen n) (list->vector (generator->list gen n)))
-      ) ;case-lambda
-    ) ;define
-
-
-    ;; generator->vector!
-    (define (generator->vector! vector at gen)
-      (let loop ((value (gen)) (count 0) (at at))
-       (cond
-         ((eof-object? value) count)
-         ((>= at (vector-length vector)) count)
-         (else (begin
-                 (vector-set! vector at value)
-                 (loop (gen) (+ count 1) (+ at 1)))
-         ) ;else
-       ) ;cond
-      ) ;let
-    ) ;define
-
-
-    ;; generator->string
-    (define generator->string
-      (case-lambda ((gen) (list->string (generator->list gen)))
-                   ((gen n) (list->string (generator->list gen n)))
-      ) ;case-lambda
-    ) ;define
-
-
-
-
-    ;; generator-fold
-    (define (generator-fold f seed . gs)
-      (define (inner-fold seed)
-        (let ((vs (map (lambda (g) (g)) gs)))
-         (if (any eof-object? vs)
-           seed
-           (inner-fold (apply f (append vs (list seed))))
-         ) ;if
-        ) ;let
-      ) ;define
-      (inner-fold seed)
-    ) ;define
-
-
-
-    ;; generator-for-each
-    (define (generator-for-each f . gs)
-      (let loop ()
-       (let ((vs (map (lambda (g) (g)) gs)))
-        (if (any eof-object? vs)
-          (if #f #f)
-          (begin (apply f vs)
-                 (loop)
-          ) ;begin
-        ) ;if
-       ) ;let
-      ) ;let
-    ) ;define
-
-    ;; generator-map->list
-    (define (generator-map->list f . gs)
-      (let loop ((result '()))
-       (let ((vs (map (lambda (g) (g)) gs)))
-        (if (any eof-object? vs)
-          (reverse result)
-          (loop (cons (apply f vs) result))
-        ) ;if
-       ) ;let
-      ) ;let
-    ) ;define
-
-
-    ;; generator-find
-    (define (generator-find pred g)
-      (let loop ((v (g)))
-        (cond ((eof-object? v) #f)
-              ((pred v) v)
-              (else (loop (g)))
-        ) ;cond
-      ) ;let
-    ) ;define
-
-    ;; generator-count
-    (define (generator-count pred g)
-      (generator-fold (lambda (v n) (if (pred v) (+ 1 n) n)) 0 g)
-    ) ;define
-
-
-    ;; generator-any
-    (define (generator-any pred gen)
-      (let loop ((item (gen)))
-        (cond ((eof-object? item) #f)
-              ((pred item))
-              (else (loop (gen)))
-        ) ;cond
-      ) ;let
-    ) ;define
-
-
-    ;; generator-every
-    (define (generator-every pred gen)
-      (let loop ((item (gen)) (last #t))
-        (if (eof-object? item)
-          last
-          (let ((r (pred item)))
-            (if r
-              (loop (gen) r)
-              #f
-            ) ;if
-          ) ;let
-        ) ;if
-      ) ;let
-    ) ;define
-
-
-    ;; generator-unfold
-    (define (generator-unfold g unfold . args)
-      (apply unfold eof-object? (lambda (x) x) (lambda (x) (g)) (g) args)
-    ) ;define
-
-
-    ;; make-accumulator
-    (define (make-accumulator kons knil finalize)
-      (let ((state knil))
-        (lambda (obj)
-          (if (eof-object? obj)
-            (finalize state)
-            (set! state (kons obj state))
-          ) ;if
-        ) ;lambda
-      ) ;let
-    ) ;define
-
-
-    ;; count-accumulator
-    (define (count-accumulator) (make-accumulator)
-                                (lambda (obj state) (+ 1 state)) 0 (lambda (x) x)
-    ) ;define
-
-    ;; list-accumulator
-    (define (list-accumulator) (make-accumulator cons '() reverse))
-
-    ;; reverse-list-accumulator
-    (define (reverse-list-accumulator) (make-accumulator cons '() (lambda (x) x)))
-
-    ;; vector-accumulator
-    (define (vector-accumulator)
-      (make-accumulator cons '() (lambda (x) (list->vector (reverse x))))
-    ) ;define
-
-    ;; reverse-vector-accumulator
-    (define (reverse-vector-accumulator)
-      (make-accumulator cons '() list->vector)
-    ) ;define
-
-    ;; vector-accumulator!
-    (define (vector-accumulator! vec at)
-      (lambda (obj)
-        (if (eof-object? obj)
-          vec
-          (begin
-            (vector-set! vec at obj)
-            (set! at (+ at 1))
-          ) ;begin
-        ) ;if
-      ) ;lambda
-    ) ;define
-
-    ;; bytevector-accumulator
-    (define (bytevector-accumulator)
-      (make-accumulator cons '() (lambda (x) (list->bytevector (reverse x))))
-    ) ;define
-
-    ;; bytevector-accumulator!
-    (define (bytevector-accumulator! bytevec at)
-      (lambda (obj)
-        (if (eof-object? obj)
-          bytevec
-          (begin
-            (bytevector-u8-set! bytevec at obj)
-            (set! at (+ at 1))
-          ) ;begin
-        ) ;if
-      ) ;lambda
-    ) ;define
-
-    ;; string-accumulator
-    (define (string-accumulator)
-      (make-accumulator cons '()
-            (lambda (lst) (list->string (reverse lst)))
-      ) ;make-accumulator
-    ) ;define
-
-    ;; sum-accumulator
-    (define (sum-accumulator) (make-accumulator + 0 (lambda (x) x)))
-
-    ;; product-accumulator
-    (define (product-accumulator) (make-accumulator * 1 (lambda (x) x)))
+    ; ;; make-iota
+    ; (define (make-iota count start step)
+    ;   (lambda ()
+    ;     (cond
+    ;       ((<= count 0)
+    ;        (eof-object)
+    ;       ) ;
+    ;       (else
+    ;         (let ((result start))
+    ;          (set! count (- count 1))
+    ;          (set! start (+ start step))
+    ;          result
+    ;         ) ;let
+    ;       ) ;else
+    ;     ) ;cond
+    ;   ) ;lambda
+    ; ) ;define
+    ;
+    ;
+    ; ;; make-range-generator
+    ; (define make-range-generator
+    ;   (case-lambda ((start end) (make-range-generator start end 1))
+    ;                ((start) (make-infinite-range-generator start))
+    ;                ((start end step)
+    ;                 (set! start (- (+ start step) step))
+    ;                 (lambda () (if (< start end)
+    ;                              (let ((v start))
+    ;                               (set! start (+ start step))
+    ;                               v
+    ;                              ) ;let
+    ;                              (eof-object))
+    ;                 ) ;lambda
+    ;                ) ;
+    ;   ) ;case-lambda
+    ; ) ;define
+    ;
+    ; (define (make-infinite-range-generator start)
+    ;   (lambda ()
+    ;     (let ((result start))
+    ;      (set! start (+ start 1))
+    ;      result
+    ;     ) ;let
+    ;   ) ;lambda
+    ; ) ;define
+    ;
+    ;
+    ;
+    ; ;; make-coroutine-generator
+    ; (define (make-coroutine-generator proc)
+    ;   (define return #f)
+    ;   (define resume #f)
+    ;   (define yield (lambda (v) (call/cc (lambda (r) (set! resume r) (return v)))))
+    ;   (lambda () (call/cc (lambda (cc) (set! return cc)
+    ;                         (if resume
+    ;                           (resume (if #f #f))  ; void? or yield again?
+    ;                           (begin (proc yield)
+    ;                                  (set! resume (lambda (v) (return (eof-object))))
+    ;                                  (return (eof-object))))
+    ;                           ) ;begin
+    ;                         ) ;if
+    ;   ) ;lambda
+    ; ) ;define
+    ;
+    ;
+    ; ;; list->generator
+    ; (define (list->generator lst)
+    ;   (lambda () (if (null? lst)
+    ;                (eof-object)
+    ;                (let ((next (car lst)))
+    ;                  (set! lst (cdr lst))
+    ;                  next)
+    ;                ) ;let
+    ;   ) ;lambda
+    ; ) ;define
+    ;
+    ;
+    ; ;; vector->generator
+    ; (define vector->generator
+    ;   (case-lambda ((vec) (vector->generator vec 0 (vector-length vec)))
+    ;                ((vec start) (vector->generator vec start (vector-length vec)))
+    ;                ((vec start end)
+    ;                 (lambda () (if (>= start end)
+    ;                              (eof-object)
+    ;                              (let ((next (vector-ref vec start)))
+    ;                                (set! start (+ start 1))
+    ;                                next)
+    ;                              ) ;let
+    ;                 ) ;lambda
+    ;                ) ;
+    ;   ) ;case-lambda
+    ; ) ;define
+    ;
+    ;
+    ; ;; reverse-vector->generator
+    ; (define reverse-vector->generator
+    ;   (case-lambda ((vec) (reverse-vector->generator vec 0 (vector-length vec)))
+    ;                ((vec start) (reverse-vector->generator vec start (vector-length vec)))
+    ;                ((vec start end)
+    ;                 (lambda () (if (>= start end)
+    ;                              (eof-object)
+    ;                              (let ((next (vector-ref vec (- end 1))))
+    ;                                (set! end (- end 1))
+    ;                                next)
+    ;                              ) ;let
+    ;                 ) ;lambda
+    ;                ) ;
+    ;   ) ;case-lambda
+    ; ) ;define
+    ;
+    ;
+    ; ;; string->generator
+    ; (define string->generator
+    ;   (case-lambda ((str) (string->generator str 0 (string-length str)))
+    ;                ((str start) (string->generator str start (string-length str)))
+    ;                ((str start end)
+    ;                 (lambda () (if (>= start end)
+    ;                              (eof-object)
+    ;                              (let ((next (string-ref str start)))
+    ;                                (set! start (+ start 1))
+    ;                                next)
+    ;                              ) ;let
+    ;                 ) ;lambda
+    ;                ) ;
+    ;   ) ;case-lambda
+    ; ) ;define
+    ;
+    ;
+    ; ;; bytevector->generator
+    ; (define bytevector->generator
+    ;   (case-lambda ((str) (bytevector->generator str 0 (bytevector-length str)))
+    ;                ((str start) (bytevector->generator str start (bytevector-length str)))
+    ;                ((str start end)
+    ;                 (lambda () (if (>= start end)
+    ;                              (eof-object)
+    ;                              (let ((next (bytevector-u8-ref str start)))
+    ;                                (set! start (+ start 1))
+    ;                                next)
+    ;                              ) ;let
+    ;                 ) ;lambda
+    ;                ) ;
+    ;   ) ;case-lambda
+    ; ) ;define
+    ;
+    ;
+    ; ;; make-for-each-generator
+    ; ;FIXME: seems to fail test
+    ; (define (make-for-each-generator for-each obj)
+    ;   (make-coroutine-generator (lambda (yield) (for-each yield obj)))
+    ; ) ;define
+    ;
+    ;
+    ; ;; make-unfold-generator
+    ; (define (make-unfold-generator stop? mapper successor seed)
+    ;   (make-coroutine-generator (lambda (yield)
+    ;                               (let loop ((s seed))
+    ;                                (if (stop? s)
+    ;                                  (if #f #f)
+    ;                                  (begin (yield (mapper s))
+    ;                                         (loop (successor s)))
+    ;                                  ) ;begin
+    ;                                ) ;if
+    ;                               ) ;let
+    ;   ) ;make-coroutine-generator
+    ; ) ;define
+    ;
+    ;
+    ; ;; gcons*
+    ; (define (gcons* . args)
+    ;   (lambda () (if (null? args)
+    ;                (eof-object)
+    ;                (if (= (length args) 1)
+    ;                  ((car args))
+    ;                  (let ((v (car args)))
+    ;                   (set! args (cdr args))
+    ;                   v)
+    ;                  ) ;let
+    ;                ) ;if
+    ;   ) ;lambda
+    ; ) ;define
+    ;
+    ;
+    ; ;; gappend
+    ; (define (gappend . args)
+    ;   (lambda () (if (null? args)
+    ;                (eof-object)
+    ;                (let loop ((v ((car args))))
+    ;                 (if (eof-object? v)
+    ;                   (begin (set! args (cdr args))
+    ;                          (if (null? args)
+    ;                            (eof-object)
+    ;                            (loop ((car args)))
+    ;                          ) ;if
+    ;                   ) ;begin
+    ;                   v)
+    ;                 ) ;if
+    ;                ) ;let
+    ;   ) ;lambda
+    ; ) ;define
+    ;
+    ; ;; gflatten
+    ; (define (gflatten gen)
+    ;   (let ((state '()))
+    ;     (lambda ()
+    ;       (if (null? state) (set! state (gen)))
+    ;       (if (eof-object? state)
+    ;         state
+    ;         (let ((obj (car state)))
+    ;           (set! state (cdr state))
+    ;           obj
+    ;         ) ;let
+    ;       ) ;if
+    ;     ) ;lambda
+    ;   ) ;let
+    ; ) ;define
+    ;
+    ; ;; ggroup
+    ; (define ggroup
+    ;   (case-lambda
+    ;     ((gen k)
+    ;      (simple-ggroup gen k)
+    ;     ) ;
+    ;     ((gen k padding)
+    ;      (padded-ggroup (simple-ggroup gen k) k padding)
+    ;     ) ;
+    ;   ) ;case-lambda
+    ; ) ;define
+    ;
+    ; (define (simple-ggroup gen k)
+    ;   (lambda ()
+    ;     (let loop ((item (gen)) (result '()) (count (- k 1)))
+    ;       (if (eof-object? item)
+    ;         (if (null? result) item (reverse result))
+    ;         (if (= count 0)
+    ;           (reverse (cons item result))
+    ;           (loop (gen) (cons item result) (- count 1))
+    ;         ) ;if
+    ;       ) ;if
+    ;     ) ;let
+    ;   ) ;lambda
+    ; ) ;define
+    ;
+    ; (define (padded-ggroup gen k padding)
+    ;   (lambda ()
+    ;     (let ((item (gen)))
+    ;       (if (eof-object? item)
+    ;         item
+    ;         (let ((len (length item)))
+    ;           (if (= len k)
+    ;               item
+    ;               (append item (make-list (- k len) padding))
+    ;           ) ;if
+    ;         ) ;let
+    ;       ) ;if
+    ;     ) ;let
+    ;   ) ;lambda
+    ; ) ;define
+    ;
+    ; ;; gmerge
+    ; (define gmerge
+    ;   (case-lambda
+    ;     ((<) (error "wrong number of arguments for gmerge"))
+    ;     ((< gen) gen)
+    ;     ((< genleft genright)
+    ;      (let ((left (genleft))
+    ;            (right (genright)))
+    ;        (lambda ()
+    ;          (cond
+    ;           ((and (eof-object? left) (eof-object? right))
+    ;            left
+    ;           ) ;
+    ;           ((eof-object? left)
+    ;            (let ((obj right)) (set! right (genright)) obj)
+    ;           ) ;
+    ;           ((eof-object? right)
+    ;            (let ((obj left))  (set! left (genleft)) obj)
+    ;           ) ;
+    ;           ((< right left)
+    ;            (let ((obj right)) (set! right (genright)) obj)
+    ;           ) ;
+    ;           (else
+    ;            (let ((obj left)) (set! left (genleft)) obj)
+    ;           ) ;else
+    ;          ) ;cond
+    ;        ) ;lambda
+    ;      ) ;let
+    ;     ) ;
+    ;     ((< . gens)
+    ;      (apply gmerge <
+    ;             (let loop ((gens gens) (gs '()))
+    ;               (cond ((null? gens) (reverse gs))
+    ;                     ((null? (cdr gens)) (reverse (cons (car gens) gs)))
+    ;                     (else
+    ;                      (loop (cddr gens)
+    ;                            (cons (gmerge < (car gens) (cadr gens)) gs)
+    ;                      ) ;loop
+    ;                     ) ;else
+    ;               ) ;cond
+    ;             ) ;let
+    ;      ) ;apply
+    ;     ) ;
+    ;   ) ;case-lambda
+    ; ) ;define
+    ;
+    ; ;; gmap
+    ; (define gmap
+    ;   (case-lambda
+    ;     ((proc) (error "wrong number of arguments for gmap"))
+    ;     ((proc gen)
+    ;      (lambda ()
+    ;        (let ((item (gen)))
+    ;          (if (eof-object? item) item (proc item))
+    ;        ) ;let
+    ;      ) ;lambda
+    ;     ) ;
+    ;     ((proc . gens)
+    ;      (lambda ()
+    ;        (let ((items (map (lambda (x) (x)) gens)))
+    ;          (if (any eof-object? items) (eof-object) (apply proc items))
+    ;        ) ;let
+    ;      ) ;lambda
+    ;     ) ;
+    ;   ) ;case-lambda
+    ; ) ;define
+    ;
+    ; ;; gcombine
+    ; (define (gcombine proc seed . gens)
+    ;   (lambda ()
+    ;     (define items (map (lambda (x) (x)) gens))
+    ;     (if (any eof-object? items)
+    ;       (eof-object)
+    ;       (let ()
+    ;        (define-values (value newseed) (apply proc (append items (list seed))))
+    ;        (set! seed newseed)
+    ;        value
+    ;       ) ;let
+    ;     ) ;if
+    ;   ) ;lambda
+    ; ) ;define
+    ;
+    ; ;; gfilter
+    ; (define (gfilter pred gen)
+    ;   (lambda () (let loop ()
+    ;               (let ((next (gen)))
+    ;                 (if (or (eof-object? next)
+    ;                         (pred next))
+    ;                   next
+    ;                   (loop))
+    ;                 ) ;if
+    ;               ) ;let
+    ;   ) ;lambda
+    ; ) ;define
+    ;
+    ; ;; gstate-filter
+    ; (define (gstate-filter proc seed gen)
+    ;   (let ((state seed))
+    ;     (lambda ()
+    ;       (let loop ((item (gen)))
+    ;         (if (eof-object? item)
+    ;           item
+    ;           (let-values (((yes newstate) (proc item state)))
+    ;             (set! state newstate)
+    ;             (if yes
+    ;                item
+    ;                (loop (gen))
+    ;             ) ;if
+    ;           ) ;let-values
+    ;         ) ;if
+    ;       ) ;let
+    ;     ) ;lambda
+    ;   ) ;let
+    ; ) ;define
+    ;
+    ;
+    ;
+    ; ;; gremove
+    ; (define (gremove pred gen)
+    ;   (gfilter (lambda (v) (not (pred v))) gen)
+    ; ) ;define
+    ;
+    ;
+    ;
+    ; ;; gtake
+    ; (define gtake
+    ;   (case-lambda ((gen k) (gtake gen k (eof-object)))
+    ;                ((gen k padding)
+    ;                 (make-coroutine-generator (lambda (yield)
+    ;                                             (if (> k 0)
+    ;                                               (let loop ((i 0) (v (gen)))
+    ;                                                (begin (if (eof-object? v) (yield padding) (yield v))
+    ;                                                       (if (< (+ 1 i) k)
+    ;                                                         (loop (+ 1 i) (gen))
+    ;                                                         (eof-object)
+    ;                                                       ) ;if
+    ;                                                ) ;begin
+    ;                                               ) ;let
+    ;                                               (eof-object))
+    ;                                             ) ;if
+    ;                 ) ;make-coroutine-generator
+    ;                ) ;
+    ;   ) ;case-lambda
+    ; ) ;define
+    ;
+    ;
+    ;
+    ; ;; gdrop
+    ; (define (gdrop gen k)
+    ;   (lambda () (do () ((<= k 0)) (set! k (- k 1)) (gen))
+    ;     (gen)
+    ;   ) ;lambda
+    ; ) ;define
+    ;
+    ;
+    ;
+    ; ;; gdrop-while
+    ; (define (gdrop-while pred gen)
+    ;   (define found #f)
+    ;   (lambda ()
+    ;     (let loop ()
+    ;      (let ((val (gen)))
+    ;       (cond (found val)
+    ;             ((and (not (eof-object? val)) (pred val)) (loop))
+    ;             (else (set! found #t) val)
+    ;       ) ;cond
+    ;      ) ;let
+    ;     ) ;let
+    ;   ) ;lambda
+    ; ) ;define
+    ;
+    ;
+    ; ;; gtake-while
+    ; (define (gtake-while pred gen)
+    ;   (lambda () (let ((next (gen)))
+    ;                (if (eof-object? next)
+    ;                  next
+    ;                  (if (pred next)
+    ;                    next
+    ;                    (begin (set! gen (generator))
+    ;                           (gen))
+    ;                    ) ;begin
+    ;                  ) ;if
+    ;                ) ;if
+    ;   ) ;lambda
+    ; ) ;define
+    ;
+    ;
+    ;
+    ; ;; gdelete
+    ; (define gdelete
+    ;   (case-lambda ((item gen) (gdelete item gen equal?))
+    ;                ((item gen ==)
+    ;                 (lambda () (let loop ((v (gen)))
+    ;                             (cond
+    ;                               ((eof-object? v) (eof-object))
+    ;                               ((== item v) (loop (gen)))
+    ;                               (else v))
+    ;                             ) ;cond
+    ;                 ) ;lambda
+    ;                ) ;
+    ;   ) ;case-lambda
+    ; ) ;define
+    ;
+    ;
+    ;
+    ; ;; gdelete-neighbor-dups
+    ; (define gdelete-neighbor-dups
+    ;   (case-lambda ((gen)
+    ;                 (gdelete-neighbor-dups gen equal?))
+    ;                ((gen ==)
+    ;                 (define firsttime #t)
+    ;                 (define prev #f)
+    ;                 (lambda () (if firsttime
+    ;                              (begin (set! firsttime #f)
+    ;                                     (set! prev (gen))
+    ;                                     prev
+    ;                              ) ;begin
+    ;                              (let loop ((v (gen)))
+    ;                               (cond
+    ;                                 ((eof-object? v)
+    ;                                  v
+    ;                                 ) ;
+    ;                                 ((== prev v)
+    ;                                  (loop (gen))
+    ;                                 ) ;
+    ;                                 (else
+    ;                                   (set! prev v)
+    ;                                   v)
+    ;                                 ) ;else
+    ;                               ) ;cond
+    ;                              ) ;let
+    ;                 ) ;lambda
+    ;                ) ;
+    ;   ) ;case-lambda
+    ; ) ;define
+    ;
+    ;
+    ; ;; gindex
+    ; (define (gindex value-gen index-gen)
+    ;   (let ((done? #f) (count 0))
+    ;    (lambda ()
+    ;      (if done?
+    ;        (eof-object)
+    ;        (let loop ((value (value-gen)) (index (index-gen)))
+    ;         (cond
+    ;           ((or (eof-object? value) (eof-object? index))
+    ;            (set! done? #t)
+    ;            (eof-object)
+    ;           ) ;
+    ;           ((= index count)
+    ;            (set! count (+ count 1))
+    ;            value
+    ;           ) ;
+    ;           (else
+    ;             (set! count (+ count 1))
+    ;             (loop (value-gen) index)
+    ;           ) ;else
+    ;         ) ;cond
+    ;        ) ;let
+    ;      ) ;if
+    ;    ) ;lambda
+    ;   ) ;let
+    ; ) ;define
+    ;
+    ;
+    ; ;; gselect
+    ; (define (gselect value-gen truth-gen)
+    ;   (let ((done? #f))
+    ;    (lambda ()
+    ;      (if done?
+    ;        (eof-object)
+    ;        (let loop ((value (value-gen)) (truth (truth-gen)))
+    ;         (cond
+    ;           ((or (eof-object? value) (eof-object? truth))
+    ;            (set! done? #t)
+    ;            (eof-object)
+    ;           ) ;
+    ;           (truth value)
+    ;           (else (loop (value-gen) (truth-gen)))
+    ;         ) ;cond
+    ;        ) ;let
+    ;      ) ;if
+    ;    ) ;lambda
+    ;   ) ;let
+    ; ) ;define
+    ;
+    ; ;; generator->list
+    ; (define generator->list
+    ;   (case-lambda
+    ;     ((gen n)
+    ;      (generator->list (gtake gen n))
+    ;     ) ;
+    ;     ((gen)
+    ;      (reverse (generator->reverse-list gen))
+    ;     ) ;
+    ;   ) ;case-lambda
+    ; ) ;define
+    ;
+    ; ;; generator->reverse-list
+    ; (define generator->reverse-list
+    ;   (case-lambda
+    ;     ((gen n)
+    ;      (generator->reverse-list (gtake gen n))
+    ;     ) ;
+    ;     ((gen)
+    ;      (generator-fold cons '() gen)
+    ;     ) ;
+    ;   ) ;case-lambda
+    ; ) ;define
+    ;
+    ; ;; generator->vector
+    ; (define generator->vector
+    ;   (case-lambda ((gen) (list->vector (generator->list gen)))
+    ;                ((gen n) (list->vector (generator->list gen n)))
+    ;   ) ;case-lambda
+    ; ) ;define
+    ;
+    ;
+    ; ;; generator->vector!
+    ; (define (generator->vector! vector at gen)
+    ;   (let loop ((value (gen)) (count 0) (at at))
+    ;    (cond
+    ;      ((eof-object? value) count)
+    ;      ((>= at (vector-length vector)) count)
+    ;      (else (begin
+    ;              (vector-set! vector at value)
+    ;              (loop (gen) (+ count 1) (+ at 1)))
+    ;      ) ;else
+    ;    ) ;cond
+    ;   ) ;let
+    ; ) ;define
+    ;
+    ;
+    ; ;; generator->string
+    ; (define generator->string
+    ;   (case-lambda ((gen) (list->string (generator->list gen)))
+    ;                ((gen n) (list->string (generator->list gen n)))
+    ;   ) ;case-lambda
+    ; ) ;define
+    ;
+    ;
+    ;
+    ;
+    ; ;; generator-fold
+    ; (define (generator-fold f seed . gs)
+    ;   (define (inner-fold seed)
+    ;     (let ((vs (map (lambda (g) (g)) gs)))
+    ;      (if (any eof-object? vs)
+    ;        seed
+    ;        (inner-fold (apply f (append vs (list seed))))
+    ;      ) ;if
+    ;     ) ;let
+    ;   ) ;define
+    ;   (inner-fold seed)
+    ; ) ;define
+    ;
+    ;
+    ;
+    ; ;; generator-for-each
+    ; (define (generator-for-each f . gs)
+    ;   (let loop ()
+    ;    (let ((vs (map (lambda (g) (g)) gs)))
+    ;     (if (any eof-object? vs)
+    ;       (if #f #f)
+    ;       (begin (apply f vs)
+    ;              (loop)
+    ;       ) ;begin
+    ;     ) ;if
+    ;    ) ;let
+    ;   ) ;let
+    ; ) ;define
+    ;
+    ; ;; generator-map->list
+    ; (define (generator-map->list f . gs)
+    ;   (let loop ((result '()))
+    ;    (let ((vs (map (lambda (g) (g)) gs)))
+    ;     (if (any eof-object? vs)
+    ;       (reverse result)
+    ;       (loop (cons (apply f vs) result))
+    ;     ) ;if
+    ;    ) ;let
+    ;   ) ;let
+    ; ) ;define
+    ;
+    ;
+    ; ;; generator-find
+    ; (define (generator-find pred g)
+    ;   (let loop ((v (g)))
+    ;     (cond ((eof-object? v) #f)
+    ;           ((pred v) v)
+    ;           (else (loop (g)))
+    ;     ) ;cond
+    ;   ) ;let
+    ; ) ;define
+    ;
+    ; ;; generator-count
+    ; (define (generator-count pred g)
+    ;   (generator-fold (lambda (v n) (if (pred v) (+ 1 n) n)) 0 g)
+    ; ) ;define
+    ;
+    ;
+    ; ;; generator-any
+    ; (define (generator-any pred gen)
+    ;   (let loop ((item (gen)))
+    ;     (cond ((eof-object? item) #f)
+    ;           ((pred item))
+    ;           (else (loop (gen)))
+    ;     ) ;cond
+    ;   ) ;let
+    ; ) ;define
+    ;
+    ;
+    ; ;; generator-every
+    ; (define (generator-every pred gen)
+    ;   (let loop ((item (gen)) (last #t))
+    ;     (if (eof-object? item)
+    ;       last
+    ;       (let ((r (pred item)))
+    ;         (if r
+    ;           (loop (gen) r)
+    ;           #f
+    ;         ) ;if
+    ;       ) ;let
+    ;     ) ;if
+    ;   ) ;let
+    ; ) ;define
+    ;
+    ;
+    ; ;; generator-unfold
+    ; (define (generator-unfold g unfold . args)
+    ;   (apply unfold eof-object? (lambda (x) x) (lambda (x) (g)) (g) args)
+    ; ) ;define
+    ;
+    ;
+    ; ;; make-accumulator
+    ; (define (make-accumulator kons knil finalize)
+    ;   (let ((state knil))
+    ;     (lambda (obj)
+    ;       (if (eof-object? obj)
+    ;         (finalize state)
+    ;         (set! state (kons obj state))
+    ;       ) ;if
+    ;     ) ;lambda
+    ;   ) ;let
+    ; ) ;define
+    ;
+    ;
+    ; ;; count-accumulator
+    ; (define (count-accumulator) (make-accumulator)
+    ;                             (lambda (obj state) (+ 1 state)) 0 (lambda (x) x)
+    ; ) ;define
+    ;
+    ; ;; list-accumulator
+    ; (define (list-accumulator) (make-accumulator cons '() reverse))
+    ;
+    ; ;; reverse-list-accumulator
+    ; (define (reverse-list-accumulator) (make-accumulator cons '() (lambda (x) x)))
+    ;
+    ; ;; vector-accumulator
+    ; (define (vector-accumulator)
+    ;   (make-accumulator cons '() (lambda (x) (list->vector (reverse x))))
+    ; ) ;define
+    ;
+    ; ;; reverse-vector-accumulator
+    ; (define (reverse-vector-accumulator)
+    ;   (make-accumulator cons '() list->vector)
+    ; ) ;define
+    ;
+    ; ;; vector-accumulator!
+    ; (define (vector-accumulator! vec at)
+    ;   (lambda (obj)
+    ;     (if (eof-object? obj)
+    ;       vec
+    ;       (begin
+    ;         (vector-set! vec at obj)
+    ;         (set! at (+ at 1))
+    ;       ) ;begin
+    ;     ) ;if
+    ;   ) ;lambda
+    ; ) ;define
+    ;
+    ; ;; bytevector-accumulator
+    ; (define (bytevector-accumulator)
+    ;   (make-accumulator cons '() (lambda (x) (list->bytevector (reverse x))))
+    ; ) ;define
+    ;
+    ; ;; bytevector-accumulator!
+    ; (define (bytevector-accumulator! bytevec at)
+    ;   (lambda (obj)
+    ;     (if (eof-object? obj)
+    ;       bytevec
+    ;       (begin
+    ;         (bytevector-u8-set! bytevec at obj)
+    ;         (set! at (+ at 1))
+    ;       ) ;begin
+    ;     ) ;if
+    ;   ) ;lambda
+    ; ) ;define
+    ;
+    ; ;; string-accumulator
+    ; (define (string-accumulator)
+    ;   (make-accumulator cons '()
+    ;         (lambda (lst) (list->string (reverse lst)))
+    ;   ) ;make-accumulator
+    ; ) ;define
+    ;
+    ; ;; sum-accumulator
+    ; (define (sum-accumulator) (make-accumulator + 0 (lambda (x) x)))
+    ;
+    ; ;; product-accumulator
+    ; (define (product-accumulator) (make-accumulator * 1 (lambda (x) x)))
   ) ;begin
 ) ;define-library
diff --git a/goldfish/srfi/srfi-165.scm b/goldfish/srfi/srfi-165.scm
index eb601a153..d1327e723 100644
--- a/goldfish/srfi/srfi-165.scm
+++ b/goldfish/srfi/srfi-165.scm
@@ -40,7 +40,8 @@
 ;; SOFTWARE.
 
 (define-library (srfi srfi-165)
-  (import (srfi srfi-1)
+  (import (scheme base)
+          (srfi srfi-1)
           (srfi srfi-128)
           (srfi srfi-125)
   ) ;import
@@ -66,12 +67,16 @@
      computation-bind/forked
 
      computation-fn
+     %fn
      computation-with
+     %with
      computation-with!
+     %with!
 
      default-computation
 
      define-computation-type
+     %define-computation-type
      make-hash-table
      variable-comparator
   ) ;export
@@ -168,72 +173,39 @@
       (vector-ref env (+ 2 (environment-variable-id var)))
     ) ;define
 
+    ;; FIXME: attempt to apply an undefined object #<undefined>
+    ;;        in (#<undefined> 'default-computation #f #f)?
     (define default-computation
       (make-computation-environment-variable 'default-computation #f #f)
     ) ;define
 
-    (define-macro (define-computation-type make-environment run . vars)
-      (letrec
-        ((process-vars
-          (lambda (vars n acc)
-            (if (null? vars)
-                (reverse acc)
-                (let ((v (car vars))
-                      (rest (cdr vars)))
-                  (cond
-                   ((and (pair? v) (pair? (cdr v)) (pair? (cddr v))
-                         (string=? (caddr v) "immutable")
-                    ) ;and
-                    (let ((var (car v))
-                          (default (cadr v)))
-                      (process-vars rest (+ n 1)
-                                    (cons (list var default #t n) acc)
-                      ) ;process-vars
-                    ) ;let
-                   ) ;
-                   ((and (pair? v) (pair? (cdr v)))
-                    (let ((var (car v))
-                          (default (cadr v)))
-                      (process-vars rest (+ n 1)
-                                    (cons (list var default #f n) acc)
-                      ) ;process-vars
-                    ) ;let
-                   ) ;
-                   (else
-                    (process-vars rest (+ n 1)
-                                  (cons (list v #f #f n) acc)))
-                    ) ;process-vars
-                   ) ;else
-                  ) ;cond
-                ) ;let
-            ) ;if
-          ) ;lambda
-        (let* ((processed (process-vars vars 0 '()))
-               (n (length processed))
-               (default-syms (map (lambda (x) (gensym "default")) processed))
-               (env-sym (gensym "env")))
-          `(begin
-             ,@(map (lambda (p ds) `(define ,ds ,(cadr p)))
-                    processed default-syms)
-             ,@(map
-                 (lambda (p ds)
-                   `(define ,(car p)
-                      (,make-environment-variable ',(car p) ,ds ,(caddr p) ,(cadddr p))))
-                 processed default-syms)
-             (define (,make-environment)
-               (let ((,env-sym (make-vector ,(+ n 2))))
-                 (,environment-set-global! ,env-sym (make-hash-table variable-comparator))
-                 (,environment-set-local! ,env-sym '())
-                 ,@(map
-                     (lambda (p ds)
-                       `(vector-set! ,env-sym ,(+ (cadddr p) 2) (,box ,ds)))
-                     processed default-syms)
-                 ,env-sym))
-             (define (,run computation)
-               (,execute computation (,make-environment))))
-        ) ;let*
-      ) ;letrec
-    ) ;define-macro
+    (define-syntax define-computation-type
+      (syntax-rules ()
+        ((define-computation-type make-environment run var ...)
+         (%define-computation-type make-environment run (var ...) 0 ()))))
+
+    (define-syntax %define-computation-type
+      (syntax-rules ()
+        ((_ make-environment run () n ((var default e immutable i) ...))
+         (begin
+           (define-values (e ...) (values default ...))
+           (define var (make-environment-variable 'var e immutable i))
+           ...
+           (define (make-environment)
+       (let ((env (make-vector (+ n 2))))
+         (environment-set-global! env (make-hash-table variable-comparator))
+         (environment-set-local! env (mapping variable-comparator))
+         (vector-set! env (+ i 2) (box e))
+         ...
+         env))
+           (define (run computation)
+       (execute computation (make-environment)))))
+        ((_ make-environment run ((v d) . v*) n (p ...))
+         (%define-computation-type make-environment run v* (+ n 1) (p ... (v d e #f n))))
+        ((_ make-environment run ((v d "immutable") . v*) n (p ...))
+         (%define-computation-type make-environment run v* (+ n 1) (p ... (v d e #t n))))
+        ((_ make-environment run (v . v*) n (p ...))
+         (%define-computation-type make-environment run v* (+ n 1) (p ... (v #f e #f n))))))
 
     (define (computation-environment-ref env var)
       (if (predefined? var)
@@ -384,75 +356,58 @@
       ) ;lambda
     ) ;define
 
-    (define-macro (computation-fn . args)
-      (let ((clauses (car args))
-            (body (cdr args)))
-        (define (parse-clauses clauses)
-          (map
-            (lambda (c)
-              (if (pair? c)
-                  (let ((id (car c))
-                        (var (cadr c)))
-                    (list id var (gensym "tmp"))
-                  ) ;let
-                  (let ((id c))
-                    (list id id (gensym "tmp")))
-                  ) ;let
-              ) ;if
-            clauses
-       ) ;map
-        ) ;define
-        (let* ((parsed (parse-clauses clauses))
-               (env-sym (gensym "env"))
-               (ids (map car parsed))
-               (vars (map cadr parsed))
-               (tmps (map caddr parsed)))
-          `(let ,(map list tmps vars)
-             (computation-bind
-              (computation-ask)
-              (lambda (,env-sym)
-                (let ,(map (lambda (id tmp)
-                             `(,id (computation-environment-ref ,env-sym ,tmp)))
-                           ids tmps)
-                  ,@body))))
-        ) ;let*
-      ) ;let
-    ) ;define-macro
-
-    (define-macro (computation-with . args)
-      (let ((bindings (car args))
-            (comps (cdr args)))
-        (let ((var-tmps (map (lambda (b) (gensym "var")) bindings))
-              (val-tmps (map (lambda (b) (gensym "val")) bindings))
-              (comp-tmps (map (lambda (c) (gensym "comp")) comps)))
-          `(let ,(append (map (lambda (b vt) `(,vt ,(car b))) bindings var-tmps)
-                         (map (lambda (b vt) `(,vt ,(cadr b))) bindings val-tmps)
-                         (map (lambda (c ct) `(,ct ,c)) comps comp-tmps))
-             (computation-local
-              (lambda (env)
-                (computation-environment-update env 
-                  ,@(apply append (map list var-tmps val-tmps))))
-              (computation-each ,@comp-tmps)))
-        ) ;let
-      ) ;let
-    ) ;define-macro
-
-    (define-macro (computation-with! . bindings)
-      (let ((var-tmps (map (lambda (b) (gensym "var")) bindings))
-            (val-tmps (map (lambda (b) (gensym "val")) bindings))
-            (env-sym (gensym "env")))
-        `(let ,(append (map (lambda (b vt) `(,vt ,(car b))) bindings var-tmps)
-                       (map (lambda (b vt) `(,vt ,(cadr b))) bindings val-tmps))
-           (computation-bind
-            (computation-ask)
-            (lambda (,env-sym)
-              ,@(map
-                  (lambda (vt val-t)
-                    `(computation-environment-update! ,env-sym ,vt ,val-t))
-                  var-tmps val-tmps)
-              (computation-pure (if #f #f)))))
-      ) ;let
-    ) ;define-macro
+    (define-syntax computation-fn
+      (syntax-rules ()
+        ((_ (clause ...) expr ... computation)
+         (%fn (clause ...) () expr ... computation))))
+
+    (define-syntax %fn
+      (syntax-rules ()
+        ((_ () ((id var tmp) ...) expr ... computation)
+         (let ((tmp var) ...)
+           (computation-bind (computation-ask)
+       (lambda (env)
+         (let ((id (computation-environment-ref env tmp)) ...)
+           expr ...
+           computation)))))
+        ((_ ((id var) . rest) (p ...) expr ... computation)
+         (%fn rest (p ... (id var tmp)) expr ... computation))
+        ((_ (id . rest) (p ...) expr ... computation)
+         (%fn rest (p ... (id id tmp)) expr ... computation))))
+
+    (define-syntax computation-with
+      (syntax-rules ()
+        ((_ ((var val) ...) a* ... a)
+         (%with ((var val) ...) () () a* ... a))))
+
+    (define-syntax %with
+      (syntax-rules ()
+        ((_ () ((x u) ...) ((a b) ...))
+         (let ((u x) ... (b a) ...)
+           (computation-local
+         (lambda (env)
+           (computation-environment-update env u ...) )
+       (computation-each b ...))))
+        ((_ ((var val) . rest) (p ...) () a* ...)
+         (%with rest (p ... (var u) (val v)) () a* ...))
+        ((_ () p* (q ...) a . a*)
+         (%with () p* (q ... (a b)) . a*))))
+
+    (define-syntax computation-with!
+      (syntax-rules ()
+        ((_ (var val) ...)
+         (%with! (var val) ... ()))))
+
+    (define-syntax %with!
+      (syntax-rules ()
+        ((_ ((var u val v) ...))
+         (let ((u var) ... (v val) ...)
+           (computation-bind (computation-ask)
+       (lambda (env)
+         (computation-environment-update! env u v) ...
+         (computation-pure (if #f #f))))))
+        ((_ (var val) r ... (p ...))
+         (%with! r ... (p ... (var u val v))))))
 
     (define (computation-forked a . a*)
       (make-computation
@@ -501,6 +456,8 @@
       ) ;fold-right
     ) ;define
 
+    ;; FIXME: (lambda () (if (quote #f) (quote #f) (void))):
+    ;;        too many arguments: ((lambda () ...) #<unspecified>)
     (define-computation-type make-computation-environment computation-run)
   ) ;begin
 ) ;define-library
diff --git a/goldfish/srfi/srfi-19.scm b/goldfish/srfi/srfi-19.scm
index 9c8923cc8..b67658aeb 100644
--- a/goldfish/srfi/srfi-19.scm
+++ b/goldfish/srfi/srfi-19.scm
@@ -47,7 +47,8 @@
 ;; WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 (define-library (srfi srfi-19)
-  (import (rename (scheme time)
+  (import (scheme base)
+          (rename (scheme time)
                   (get-time-of-day      glue:get-time-of-day)
                   (monotonic-nanosecond glue:monotonic-nanosecond))
           (only (srfi srfi-13) string-pad string-tokenize string-trim-right)
@@ -69,24 +70,25 @@
     ;; Time arithmetic procedures
     add-duration subtract-duration time-difference
     ;; Current time and clock resolution
-    current-date current-julian-day current-time time-resolution
-    local-tz-offset
-    ;; Date object and accessors
-    make-date date?
-    date-nanosecond date-second date-minute date-hour
-    date-day        date-month  date-year   date-zone-offset
-    date-year-day
-    date-week-day date-week-number
-    ;; Time/Date/Julian Day/Modified Julian Day Converters
-    time-utc->time-tai time-tai->time-utc
-    time-utc->time-monotonic time-monotonic->time-utc
-    time-tai->time-monotonic time-monotonic->time-tai
-    time-utc->date date->time-utc
-    time-tai->date date->time-tai 
-    time-monotonic->date date->time-monotonic
-    date->julian-day date->modified-julian-day
-    ;; Date to String/String to Date Converters
-    date->string string->date)
+    ; current-date current-julian-day current-time time-resolution
+    ; local-tz-offset
+    ; ;; Date object and accessors
+    ; make-date date?
+    ; date-nanosecond date-second date-minute date-hour
+    ; date-day        date-month  date-year   date-zone-offset
+    ; date-year-day
+    ; date-week-day date-week-number
+    ; ;; Time/Date/Julian Day/Modified Julian Day Converters
+    ; time-utc->time-tai time-tai->time-utc
+    ; time-utc->time-monotonic time-monotonic->time-utc
+    ; time-tai->time-monotonic time-monotonic->time-tai
+    ; time-utc->date date->time-utc
+    ; time-tai->date date->time-tai 
+    ; time-monotonic->date date->time-monotonic
+    ; date->julian-day date->modified-julian-day
+    ; ;; Date to String/String to Date Converters
+    ; date->string string->date
+    )
   (begin
 
     ;; ====================
@@ -332,941 +334,941 @@
       (receive (s us) (glue:get-time-of-day)
         (make-time TIME-UTC (priv:us->ns us) s)))
 
-    (define priv:TIME-DISPATCH
-       `((,TIME-MONOTONIC . (,priv:current-time-monotonic . ,steady-clock-resolution))
-         ; (,TIME-PROCESS   . (,priv:current-time-process   . ,0))
-         (,TIME-TAI       . (,priv:current-time-tai       . ,system-clock-resolution))
-         ; (,TIME-THREAD    . (,priv:current-time-thread    . ,0))
-         (,TIME-UTC       . (,priv:current-time-utc       . ,system-clock-resolution))))
+    ; (define priv:TIME-DISPATCH
+    ;    `((,TIME-MONOTONIC . (,priv:current-time-monotonic . ,steady-clock-resolution))
+    ;      ; (,TIME-PROCESS   . (,priv:current-time-process   . ,0))
+    ;      (,TIME-TAI       . (,priv:current-time-tai       . ,system-clock-resolution))
+    ;      ; (,TIME-THREAD    . (,priv:current-time-thread    . ,0))
+    ;      (,TIME-UTC       . (,priv:current-time-utc       . ,system-clock-resolution))))
     (define (priv:query-time-dispatch clock-type querier)
       (let ((entry (assq clock-type priv:TIME-DISPATCH)))
         (if entry
           (querier entry)
           (error 'wrong-type-arg "unsupported time type" clock-type))))
-
-    ;; ====================
-
-    (define (priv:round-offset-to-minute offset)
-      (let* ((sign (if (negative? offset) -1 1))
-             (abs-off (abs offset))
-             (q (quotient abs-off 60))
-             (r (remainder abs-off 60)))
-        (* sign (if (>= r 30) (+ q 1) q) 60)))
-
-    (define (local-tz-offset)
-      (let ((time-vec (g_datetime-now)))
-        (if (and (vector? time-vec) (= (vector-length time-vec) 7))
-          (let* ((year   (vector-ref time-vec 0))
-                 (month  (vector-ref time-vec 1))
-                 (day    (vector-ref time-vec 2))
-                 (hour   (vector-ref time-vec 3))
-                 (minute (vector-ref time-vec 4))
-                 (second (vector-ref time-vec 5)))
-            (receive (utc-sec utc-usec) (glue:get-time-of-day)
-              (let*
-                ((days (priv:days-since-epoch year month day))
-                 (local-sec
-                   (+ (* days priv:SID)
-                      (* hour 3600)
-                      (* minute 60)
-                      second))
-                 (offset (- local-sec utc-sec)))
-                (priv:round-offset-to-minute offset))))
-          0)))
-
-    (define* (current-date (tz-offset (local-tz-offset)))
-      (time-utc->date (current-time TIME-UTC) tz-offset))
-
-    (define (current-julian-day)
-      (error 'todo "TODO"))
-
-    (define* (current-time (clock-type TIME-UTC))
-      ((priv:query-time-dispatch clock-type cadr)))
-
-    (define* (time-resolution (clock-type TIME-UTC))
-      (priv:query-time-dispatch clock-type cddr))
-
-    ;; ====================
-    ;; Date object and accessors
-    ;; ====================
-
-    ;; Date objects are immutable once created
-    (define-record-type <date>
-      (%make-date nanosecond second minute hour day month year zone-offset)
-      date?
-      (nanosecond  date-nanosecond)
-      (second      date-second)
-      (minute      date-minute)
-      (hour        date-hour)
-      (day         date-day)
-      (month       date-month)
-      (year        date-year)
-      (zone-offset date-zone-offset))
-
-    (define (make-date nanosecond second minute hour day month year zone-offset)
-      ;; TODO: more guards maybe
-      (unless (and (integer? nanosecond) (integer? second)
-                   (integer? minute)     (integer? hour)
-                   (integer? day)        (integer? month)
-                   (integer? year)       (integer? zone-offset))
-        (error 'wrong-type-arg "The date fields need to be integer"))
-      (%make-date nanosecond second minute hour day month year zone-offset))
-
-    ;; ====================
-
-    (define (priv:leap-year? year)
-      (cond
-        ((zero? (modulo year 400)) #t)
-        ((zero? (modulo year 100)) #f)
-        ((zero? (modulo year 4))   #t)
-        (else                      #f)))
-
-    (define priv:MONTH-ASSOC '((0 . 0)   (1 . 31)  (2 . 59)   (3 . 90)
-                               (4 . 120) (5 . 151) (6 . 181)  (7 . 212)
-                               (8 . 243) (9 . 273) (10 . 304) (11 . 334)))
-
-    (define (priv:year-day day month year)
-      (let ((days-pr (assoc (- month 1) priv:MONTH-ASSOC)))
-        (unless days-pr
-          (value-error "invalid month specified" month))
-        ;; 闰2月，所以2月之后，且当年是闰年的，要多一天
-        (if (and (priv:leap-year? year) (> month 2))
-          (+ day (cdr days-pr) 1)
-          (+ day (cdr days-pr)))))
-
-    ;; ====================
-
-    (define (priv:week-day day month year)
-      (let* ((yy (if (negative? year) (+ year 1) year))
-             (a (quotient (- 14 month) 12))
-             (y (- yy a))
-             (m (+ month (* 12 a) -2)))
-        (modulo
-          (+ day
-             y
-             (floor-quotient y 4)
-             (- (floor-quotient y 100))
-             (floor-quotient y 400)
-             (floor-quotient (* 31 m) 12))
-                7)))
-
-    (define (priv:days-before-first-week date day-of-week-starting-week)
-      (let*
-        ((first-day
-           (make-date 0 0 0 0
-                      1
-                      1
-                      (date-year date)
-                      0))
-         (fdweek-day (date-week-day first-day)))
-        (modulo (- day-of-week-starting-week fdweek-day)
-                7)))
-
-    (define (date-year-day date)
-      (priv:year-day (date-day   date)
-                     (date-month date)
-                     (date-year  date)))
-
-    (define (date-week-day date)
-      (priv:week-day (date-day   date)
-                     (date-month date)
-                     (date-year  date)))
-
-    (define (date-week-number date day-of-week-starting-week)
-      (floor-quotient
-        (- (date-year-day date)
-           1
-           (priv:days-before-first-week date day-of-week-starting-week))
-        7))
-
-    ;; ====================
-    ;; Time/Date/Julian Day/Modified Julian Day Converters
-    ;; ====================
-
-    (define (priv:tai->utc-seconds tai-sec)
-      (let lp ((table priv:leap-second-table))
-        (cond
-          ((null? table) (- tai-sec 10))
-          (else
-            (let* ((utc-start (caar table))
-                   (delta (cdar table))
-                   (tai-start (+ utc-start delta)))
-              (if (>= tai-sec tai-start)
-                (- tai-sec delta)
-                (lp (cdr table))))))))
-
-    (define (time-utc->time-tai time-utc)
-      (unless (and (time? time-utc) (eq? (time-type time-utc) TIME-UTC))
-        (error 'wrong-type-arg "time-utc->time-tai: time-utc must be a TIME-UTC object" time-utc))
-      (make-time TIME-TAI
-                 (time-nanosecond time-utc)
-                 (+ (time-second time-utc)
-                    (priv:leap-second-delta (time-second time-utc)))))
-
-    (define (time-tai->time-utc time-tai)
-      (unless (and (time? time-tai) (eq? (time-type time-tai) TIME-TAI))
-        (error 'wrong-type-arg "time-tai->time-utc: time-tai must be a TIME-TAI object" time-tai))
-      (make-time TIME-UTC
-                 (time-nanosecond time-tai)
-                 (priv:tai->utc-seconds (time-second time-tai))))
-
-    (define (time-utc->time-monotonic time-utc)
-      (unless (and (time? time-utc) (eq? (time-type time-utc) TIME-UTC))
-        (error 'wrong-type-arg "time-utc->time-monotonic: time-utc must be a TIME-UTC object" time-utc))
-      (make-time TIME-MONOTONIC
-                 (time-nanosecond time-utc)
-                 (time-second time-utc)))
-
-    (define (time-monotonic->time-utc time-monotonic)
-      (unless (and (time? time-monotonic)
-                   (eq? (time-type time-monotonic) TIME-MONOTONIC))
-        (error 'wrong-type-arg
-               "time-monotonic->time-utc: time-monotonic must be a TIME-MONOTONIC object"
-               time-monotonic))
-      (make-time TIME-UTC
-                 (time-nanosecond time-monotonic)
-                 (time-second time-monotonic)))
-
-    (define (time-tai->time-monotonic time-tai)
-      (unless (and (time? time-tai) (eq? (time-type time-tai) TIME-TAI))
-        (error 'wrong-type-arg
-               "time-tai->time-monotonic: time-tai must be a TIME-TAI object"
-               time-tai))
-      (time-utc->time-monotonic (time-tai->time-utc time-tai)))
-
-    (define (time-monotonic->time-tai time-monotonic)
-      (unless (and (time? time-monotonic)
-                   (eq? (time-type time-monotonic) TIME-MONOTONIC))
-        (error 'wrong-type-arg
-               "time-monotonic->time-tai: time-monotonic must be a TIME-MONOTONIC object"
-               time-monotonic))
-      (time-utc->time-tai (time-monotonic->time-utc time-monotonic)))
-
-    (define (priv:days-since-epoch year month day)
-      ;; Howard Hinnant's days_from_civil algorithm, inverse of civil-from-days
-      (let*
-        ((y (- year (if (<= month 2) 1 0)))
-         (era (if (>= y 0)
-                (floor-quotient y 400)
-                (floor-quotient (- y 399) 400)))
-         (yoe (- y (* era 400)))
-         (m (+ month (if (> month 2) -3 9))) ; March=0, ..., February=11
-         (doy (+ (floor-quotient (+ (* 153 m) 2) 5) (- day 1)))
-         (doe
-           (+ (* yoe 365)
-              (floor-quotient yoe 4)
-              (- (floor-quotient yoe 100))
-              doy)))
-        (- (+ (* era 146097) doe) 719468)))
-
-    (define (priv:civil-from-days days)
-      ;; Howard Hinnant's algorithm, adapted for proleptic Gregorian calendar
-      (let*
-        ((z (+ days 719468))
-         (era (if (>= z 0)
-                (floor-quotient z 146097)
-                (floor-quotient (- z 146096) 146097)))
-         (doe (- z (* era 146097))) ; [0, 146096]
-         (yoe
-           (floor-quotient (- doe (floor-quotient doe 1460)
-                             (- (floor-quotient doe 36524))
-                             (floor-quotient doe 146096))
-                           365))
-         (y (+ yoe (* era 400)))
-         (doy
-           (- doe (+ (* 365 yoe)
-                     (floor-quotient yoe 4)
-                     (- (floor-quotient yoe 100)))))
-         (mp (floor-quotient (+ (* 5 doy) 2) 153))
-         (d (+ (- doy (floor-quotient (+ (* 153 mp) 2) 5)) 1))
-         (m (+ mp (if (< mp 10) 3 -9)))
-         (y (if (<= m 2) (+ y 1) y)))
-        (values y m d)))
-
-    ;; Default tz-offset uses local time zone from OS.
-    (define* (time-utc->date time-utc (tz-offset (local-tz-offset)))
-      (unless (and (time? time-utc) (eq? (time-type time-utc) TIME-UTC))
-        (error 'wrong-type-arg "time-utc->date: time-utc must be a TIME-UTC object" time-utc))
-      (unless (integer? tz-offset)
-        (error 'wrong-type-arg "time-utc->date: tz-offset must be an integer" tz-offset))
-      (let* ((sec (+ (time-second time-utc) tz-offset))
-             (nsec (time-nanosecond time-utc)))
-        (receive (days day-sec) (floor/ sec priv:SID)
-          (receive (year month day) (priv:civil-from-days days)
-            (receive (hour rem1) (floor/ day-sec 3600)
-              (receive (minute second) (floor/ rem1 60)
-                (make-date nsec second minute hour day month year tz-offset)))))))
-
-    (define (date->time-utc date)
-      (unless (date? date)
-        (error 'wrong-type-arg "date->time-utc: date must be a date object" date))
-      (let*
-        ((days
-           (priv:days-since-epoch (date-year date)
-                                  (date-month date)
-                                  (date-day date)))
-         (local-sec
-           (+ (* days priv:SID)
-              (* (date-hour date) 3600)
-              (* (date-minute date) 60)
-              (date-second date)))
-         (utc-sec (- local-sec (date-zone-offset date))))
-        (make-time TIME-UTC (date-nanosecond date) utc-sec)))
-
-    ;; Default tz-offset uses local time zone from OS.
-    (define* (time-tai->date time-tai (tz-offset (local-tz-offset)))
-      (unless (and (time? time-tai) (eq? (time-type time-tai) TIME-TAI))
-        (error 'wrong-type-arg "time-tai->date: time-tai must be a TIME-TAI object" time-tai))
-      (unless (integer? tz-offset)
-        (error 'wrong-type-arg "time-tai->date: tz-offset must be an integer" tz-offset))
-      (time-utc->date (time-tai->time-utc time-tai) tz-offset))
-
-    (define (date->time-tai date)
-      (time-utc->time-tai (date->time-utc date)))
-
-    ;; Default tz-offset uses local time zone from OS.
-    (define* (time-monotonic->date time-monotonic (tz-offset (local-tz-offset)))
-      (unless (and (time? time-monotonic)
-                   (eq? (time-type time-monotonic) TIME-MONOTONIC))
-        (error 'wrong-type-arg
-               "time-monotonic->date: time-monotonic must be a TIME-MONOTONIC object"
-               time-monotonic))
-      (unless (integer? tz-offset)
-        (error 'wrong-type-arg "time-monotonic->date: tz-offset must be an integer" tz-offset))
-      (time-utc->date (time-monotonic->time-utc time-monotonic) tz-offset))
-
-    (define (date->time-monotonic date)
-      (unless (date? date)
-        (error 'wrong-type-arg "date->time-monotonic: date must be a date object" date))
-      (time-utc->time-monotonic (date->time-utc date)))
-
-    (define (date->julian-day date)
-      (unless (date? date)
-        (error 'wrong-type-arg "date->julian-day: date must be a date object" date))
-      (let* ((t (time-utc->time-monotonic (date->time-utc date)))
-             (secs (time-second t))
-             (nsecs (time-nanosecond t))
-             (total-secs (+ secs (/ nsecs priv:NANO))))
-        (+ priv:TAI-EPOCH-IN-JD (/ total-secs priv:SID))))
-
-    (define (date->modified-julian-day date)
-      (- (date->julian-day date) 4800001/2))
-
-    ;; ====================
-    ;; Date to String/String to Date Converters
-    ;; ====================
-
-    (define (priv:locale-abbr-weekday n)
-      (vector-ref priv:LOCALE-ABBR-WEEKDAY-VECTOR n))
-    (define (priv:locale-long-weekday n)
-      (vector-ref priv:LOCALE-LONG-WEEKDAY-VECTOR n))
-    (define (priv:locale-abbr-month n)
-      (vector-ref priv:LOCALE-ABBR-MONTH-VECTOR n))
-    (define (priv:locale-long-month n)
-      (vector-ref priv:LOCALE-LONG-MONTH-VECTOR n))
-
-    ;; Only handles positive integers `n`. Internal use only.
-    (define (priv:padding n pad-with len)
-      (let* ((str     (number->string n))
-             (str-len (string-length str)))
-        (cond
-          ((or (> str-len len) (not pad-with)) str)
-          (else (string-pad str len pad-with)))))
-
-    (define (priv:locale-am/pm hr)
-      (if (> hr 11) priv:LOCALE-PM priv:LOCALE-AM))
-
-    (define (priv:date-week-number-iso date)
-      (let* ((year (date-year date))
-             (jan1-wday (priv:week-day 1 1 year))
-             (offset (if (> jan1-wday 4) 0 1))
-             ;; 调整值：补偿 1-based 和 周日归属
-             (adjusted (+ (date-year-day date) jan1-wday -2))
-             (raw-week (+ (floor-quotient adjusted 7) offset)))
-        (cond
-          ((zero? raw-week)
-           (priv:date-week-number-iso 
-            (make-date 0 0 0 0 31 12 (- year 1) 0)))
-
-          ((and (= raw-week 53)
-                (<= (priv:week-day 1 1 (+ year 1)) 4))
-           1)
-
-          (else raw-week))))
-
-    (define (priv:last-n-digits i n)
-      (modulo i (expt 10 n)))
-
-    (define (priv:tz-printer offset port)
-      (cond
-        ((zero? offset)     (display "Z" port))
-        ((negative? offset) (display "-" port))
-        (else               (display "+" port)))
-      (unless (zero? offset)
-        (let ((hours   (abs (quotient offset (* 60 60))))
-              (minutes (abs (quotient (remainder offset (* 60 60)) 60))))
-          (display (priv:padding hours   #\0 2) port)
-          (display (priv:padding minutes #\0 2) port))))
-
-    (define (priv:directives/formatter char format-string)
-      (lambda (date pad-with port)
-        (case char
-          ((#\~) (display #\~ port))
-          ((#\a)
-           (display (priv:locale-abbr-weekday (date-week-day date))
-                    port))
-          ((#\A)
-           (display (priv:locale-long-weekday (date-week-day date))
-                    port))
-          ((#\b #\h)
-           (display (priv:locale-abbr-month (date-month date))
-                    port))
-          ((#\B)
-           (display (priv:locale-long-month (date-month date))
-                    port))
-          ((#\c)
-           (display (date->string date priv:LOCALE-DATE-TIME-FORMAT)
-                    port))
-          ((#\d)
-           (display (priv:padding (date-day date) #\0 2)
-                    port))
-          ((#\D)
-           (display (date->string date "~m/~d/~y")
-                    port))
-          ((#\e)
-           (display (priv:padding (date-day date) #\space 2)
-                    port))
-          ;; ref Guile
-          ((#\f)
-           (receive (s ns)
-                    (floor/ (+ (* (date-second date) priv:NANO)
-                               (date-nanosecond date))
-                            priv:NANO)
-             (display (number->string s) port)
-             (display priv:LOCALE-DECIMAL-POINT port)
-             (let ((str (priv:padding ns #\0 9)))
-               (display (substring str 0 1) port)
-               (display (string-trim-right str #\0 1) port))))
-          ((#\H)
-           (display (priv:padding (date-hour date)
-                                  pad-with 2)
-                    port))
-          ((#\I)
-           (display (priv:padding (+ 1 (modulo (- (date-hour date) 1) 12))
-                                  pad-with
-                                  2)
-                    port))
-          ((#\j)
-           (display (priv:padding (date-year-day date)
-                                  pad-with 3)
-                    port))
-          ((#\k)
-           (display (priv:padding (date-hour date)
-                                  #\space 2)
-                    port))
-          ((#\l)
-           (display (priv:padding (+ 1 (modulo (- (date-hour date) 1) 12))
-                                  #\space
-                                  2)
-                    port))
-          ((#\m)
-           (display (priv:padding (date-month date)
-                                  pad-with 2)
-                    port))
-          ((#\M)
-           (display (priv:padding (date-minute date)
-                                  pad-with 2)
-                    port))
-          ((#\n) (newline port))
-          ((#\N)
-           (display (priv:padding (date-nanosecond date)
-                                  pad-with 9)
-                    port))
-          ((#\p) (display (priv:locale-am/pm (date-hour date)) port))
-          ((#\r) (display (date->string date "~I:~M:~S ~p") port))
-
-          ((#\s) (error "Not Implement"))
-          ((#\S)
-           (let ((sec-delta (if (> (date-nanosecond date) priv:NANO)
-                              1 0)))
-             (display
-               (priv:padding (+ (date-second date) sec-delta)
-                             pad-with 2)
-                      port)))
-
-          ((#\t) (display #\tab port))
-          ((#\T) (display (date->string date "~H:~M:~S") port))
-          ((#\U)
-           (let* ((week>0?   (> (priv:days-before-first-week date 0) 0))
-                  (week-num  (date-week-number date 0))
-                  (week-num* (if week>0? (+ week-num 1) week-num)))
-             (display (priv:padding week-num* #\0 2) port)))
-
-          ((#\V)
-           (display (priv:padding (priv:date-week-number-iso date)
-                                  #\0 2) port))
-          ((#\w) (display (date-week-day date) port))
-          ((#\W)
-           (let* ((week>1?   (> (priv:days-before-first-week date 1) 0))
-                  (week-num  (date-week-number date 1))
-                  (week-num* (if week>1? (+ week-num 1) week-num)))
-             (display (priv:padding week-num* #\0 2) port)))
-          ((#\x) (display (date->string date priv:LOCALE-SHORT-DATE-FORMAT) port))
-          ((#\X) (display (date->string date priv:LOCALE-TIME-FORMAT) port))
-          ((#\y)
-           (display (priv:padding (priv:last-n-digits (date-year date) 2)
-                                  pad-with 2)
-                    port))
-          ((#\Y)
-           (display (priv:padding (date-year date) pad-with 4)
-                    port))
-          ((#\z) (priv:tz-printer (date-zone-offset date) port))
-          ((#\Z) (error "Not Implement"))
-          ((#\1) (display (date->string date "~Y-~m-~d") port))
-          ((#\2) (display (date->string date "~H:~M:~S~z") port))
-          ((#\3) (display (date->string date "~H:~M:~S") port))
-          ((#\4) (display (date->string date "~Y-~m-~dT~H:~M:~S~z") port))
-          ((#\5) (display (date->string date "~Y-~m-~dT~H:~M:~S") port))
-          (else (priv:bad-format-error format-string)))))
-
-    (define (priv:bad-format-error format-string)
-      (value-error "bad date format string" format-string))
-
-    (define (priv:date-printer date format-string format-string-port port)
-      (let ((current-char (read-char format-string-port))
-            (pad-char     (peek-char format-string-port)))
-        (cond
-          ((eof-object? current-char) (values))
-
-          ((and (eof-object? pad-char)
-                ;; unfinished directives
-                (char=? current-char #\~))
-           (priv:bad-format-error format-string))
-
-          ((and (char=? current-char #\~)
-                (or (char=? pad-char #\-) (char=? pad-char #\_)))
-           (let ((pad-pad-char (begin (read-char format-string-port)
-                                      (peek-char format-string-port))))
-             (if (eof-object? pad-pad-char)
-               (priv:bad-format-error format-string)
-               (let ((formatter (priv:directives/formatter pad-pad-char format-string))
-                     (pad-with  (if (char=? pad-char #\-) #f #\space)))
-                 (begin (formatter date pad-with port)
-                        (priv:date-printer date format-string
-                                           format-string-port port))))))
-
-          ((char=? current-char #\~)
-           (let ((formatter (priv:directives/formatter pad-char format-string)))
-             (begin (formatter date #\0 port)
-                    (read-char format-string-port) ; consume
-                    (priv:date-printer date format-string
-                                       format-string-port port))))
-
-          (else
-            (display current-char port)
-            (priv:date-printer date format-string
-                               format-string-port port)))))
-
-    (define* (date->string date (format-string "~c"))
-      (let ((str-port (open-output-string)))
-        (priv:date-printer date format-string
-                   (open-input-string format-string)
-                   str-port)
-        (get-output-string str-port)))
-
-    (define (priv:string-ci-prefix? str pos prefix)
-      (let* ((plen (string-length prefix))
-             (slen (string-length str)))
-        (and (<= (+ pos plen) slen)
-             (let loop ((i 0))
-               (cond
-                 ((= i plen) #t)
-                 ((char=? (char-downcase (string-ref str (+ pos i)))
-                          (char-downcase (string-ref prefix i)))
-                  (loop (+ i 1)))
-                 (else #f))))))
-
-    (define (priv:skip-to pred str pos)
-      (let ((len (string-length str)))
-        (let loop ((i pos))
-          (cond
-            ((>= i len)
-             (value-error "string->date: input does not match template" str))
-            ((pred (string-ref str i)) i)
-            (else (loop (+ i 1)))))))
-
-    (define (priv:read-digits str pos)
-      (let ((len (string-length str)))
-        (let loop ((i pos))
-          (if (and (< i len) (char-numeric? (string-ref str i)))
-            (loop (+ i 1))
-            (if (= i pos)
-              (value-error "string->date: expected digits" str)
-              (values (substring str pos i) i))))))
-
-    (define (priv:read-fixed-digits str pos n)
-      (let ((end (+ pos n))
-            (len (string-length str)))
-        (when (> end len)
-          (value-error "string->date: expected digits" str))
-        (let loop ((i pos))
-          (if (= i end)
-            (values (substring str pos end) end)
-            (if (char-numeric? (string-ref str i))
-              (loop (+ i 1))
-              (value-error "string->date: expected digits" str))))))
-
-    (define (priv:match-locale str pos vec)
-      (let ((len (vector-length vec)))
-        (let loop ((i 0) (best-index #f) (best-len 0))
-          (if (= i len)
-            (if best-index
-              (values best-index (+ pos best-len))
-              (value-error "string->date: invalid locale name" str))
-            (let ((name (vector-ref vec i)))
-              (if (and (string? name)
-                       (> (string-length name) 0)
-                       (priv:string-ci-prefix? str pos name))
-                (let ((nlen (string-length name)))
-                  (if (> nlen best-len)
-                    (loop (+ i 1) i nlen)
-                    (loop (+ i 1) best-index best-len)))
-                (loop (+ i 1) best-index best-len)))))))
-
-    (define (string->date input-string template-string)
-      (unless (and (string? input-string) (string? template-string))
-        (error 'wrong-type-arg
-               "string->date: input-string and template-string must be strings"
-               (list input-string template-string)))
-      (let* ((input input-string)
-             (len (string-length input))
-             (year #f)
-             (month #f)
-             (day #f)
-             (hour #f)
-             (minute #f)
-             (second #f)
-             (nanosecond #f)
-             (zone-offset #f)
-             (year-day #f)
-             (week-day #f)
-             (week-number #f)
-             (week-start #f)
-             (week-number-iso #f)
-             (hour12 #f)
-             (ampm #f))
-
-        (define (priv:expect-char pos ch)
-          (if (and (< pos len) (char=? (string-ref input pos) ch))
-            (+ pos 1)
-            (value-error "string->date: input does not match template"
-                         (list input template-string))))
-
-        (define (priv:read-number pos skip-pred allow-space? allow-sign?)
-          (let*
-            ((pos (if skip-pred (priv:skip-to skip-pred input pos) pos))
-             (pos (if (and allow-space?
-                           (< pos len)
-                           (char=? (string-ref input pos) #\space))
-                    (+ pos 1)
-                    pos))
-             (start pos)
-             (pos (if (and allow-sign?
-                           (< pos len)
-                           (or (char=? (string-ref input pos) #\+)
-                               (char=? (string-ref input pos) #\-)))
-                    (+ pos 1)
-                    pos)))
-            (receive (digits end) (priv:read-digits input pos)
-              (values (string->number (substring input start end)) end))))
-
-        (define (priv:parse-tz-offset pos)
-          (cond
-            ((and (< pos len) (char=? (string-ref input pos) #\Z))
-             (values 0 (+ pos 1)))
-            ((and (< pos len)
-                  (or (char=? (string-ref input pos) #\+)
-                      (char=? (string-ref input pos) #\-)))
-             (let* ((sign (if (char=? (string-ref input pos) #\-) -1 1))
-                    (pos (+ pos 1)))
-               (receive (hh pos1) (priv:read-fixed-digits input pos 2)
-                 (let ((pos2 pos1))
-                   (if (and (< pos2 len) (char=? (string-ref input pos2) #\:))
-                     (set! pos2 (+ pos2 1)))
-                   (receive (mm pos3) (priv:read-fixed-digits input pos2 2)
-                     (values (* sign (+ (* (string->number hh) 3600)
-                                        (* (string->number mm) 60)))
-                             pos3))))))
-            (else
-             (value-error "string->date: invalid time zone offset" input))))
-
-        (define (priv:resolve-two-digit-year y)
-          (let* ((y2 (modulo y 100))
-                 (cur-year (date-year (current-date 0)))
-                 (century (* (quotient cur-year 100) 100))
-                 (candidate (+ century y2)))
-            (cond
-              ((< candidate (- cur-year 50)) (+ candidate 100))
-              ((> candidate (+ cur-year 49)) (- candidate 100))
-              (else candidate))))
-
-        (define (priv:parse-directive dir pos)
-          (case dir
-            ((#\~) (priv:expect-char pos #\~))
-            ((#\n) (priv:expect-char pos #\newline))
-            ((#\t) (priv:expect-char pos #\tab))
-            ((#\a)
-             (let ((pos (priv:skip-to char-alphabetic? input pos)))
-               (receive
-                 (idx pos2) (priv:match-locale input pos
-                                              priv:LOCALE-ABBR-WEEKDAY-VECTOR)
-                 pos2)))
-            ((#\A)
-             (let ((pos (priv:skip-to char-alphabetic? input pos)))
-               (receive
-                 (idx pos2) (priv:match-locale input pos
-                                              priv:LOCALE-LONG-WEEKDAY-VECTOR)
-                 pos2)))
-            ((#\b #\h)
-             (let ((pos (priv:skip-to char-alphabetic? input pos)))
-               (receive
-                 (idx pos2) (priv:match-locale input pos
-                                              priv:LOCALE-ABBR-MONTH-VECTOR)
-                 (set! month idx)
-                 pos2)))
-            ((#\B)
-             (let ((pos (priv:skip-to char-alphabetic? input pos)))
-               (receive
-                 (idx pos2) (priv:match-locale input pos
-                                              priv:LOCALE-LONG-MONTH-VECTOR)
-                 (set! month idx)
-                 pos2)))
-            ((#\c) (priv:parse-template priv:LOCALE-DATE-TIME-FORMAT pos))
-            ((#\D) (priv:parse-template "~m/~d/~y" pos))
-            ((#\d)
-             (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
-               (set! day v)
-               pos2))
-            ((#\e)
-             (receive (v pos2) (priv:read-number pos #f #t #f)
-               (set! day v)
-               pos2))
-            ((#\f)
-             (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
-               (set! second v)
-               (let ((pos3 pos2))
-                 (if (and (< pos3 len)
-                          (char=? (string-ref input pos3)
-                                  (string-ref priv:LOCALE-DECIMAL-POINT 0)))
-                   (begin
-                     (set! pos3 (+ pos3 1))
-                     (receive (frac pos4) (priv:read-digits input pos3)
-                       (let ((flen (string-length frac)))
-                         (when (> flen 9)
-                           (value-error "string->date: invalid fractional seconds" input))
-                         (set! nanosecond
-                               (* (string->number frac) (expt 10 (- 9 flen)))))
-                       pos4))
-                   (begin
-                     (set! nanosecond 0)
-                     pos3)))))
-            ((#\H)
-             (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
-               (set! hour v)
-               pos2))
-            ((#\I)
-             (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
-               (set! hour12 v)
-               pos2))
-            ((#\j)
-             (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
-               (set! year-day v)
-               pos2))
-            ((#\k)
-             (receive (v pos2) (priv:read-number pos #f #t #f)
-               (set! hour v)
-               pos2))
-            ((#\l)
-             (receive (v pos2) (priv:read-number pos #f #t #f)
-               (set! hour12 v)
-               pos2))
-            ((#\m)
-             (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
-               (set! month v)
-               pos2))
-            ((#\M)
-             (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
-               (set! minute v)
-               pos2))
-            ((#\N)
-             (let ((pos (priv:skip-to char-numeric? input pos)))
-               (receive (digits pos2) (priv:read-digits input pos)
-                 (when (> (string-length digits) 9)
-                   (value-error "string->date: invalid nanosecond" input))
-                 (set! nanosecond (string->number digits))
-                 pos2)))
-            ((#\p)
-             (let ((pos (priv:skip-to char-alphabetic? input pos)))
-               (cond
-                 ((priv:string-ci-prefix? input pos priv:LOCALE-AM)
-                  (set! ampm 'am)
-                  (+ pos (string-length priv:LOCALE-AM)))
-                 ((priv:string-ci-prefix? input pos priv:LOCALE-PM)
-                  (set! ampm 'pm)
-                  (+ pos (string-length priv:LOCALE-PM)))
-                 (else
-                  (value-error "string->date: invalid am/pm" input)))))
-            ((#\r) (priv:parse-template "~I:~M:~S ~p" pos))
-            ((#\s) (error "Not Implement"))
-            ((#\S)
-             (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
-               (set! second v)
-               pos2))
-            ((#\T) (priv:parse-template "~H:~M:~S" pos))
-            ((#\U)
-             (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
-               (set! week-number v)
-               (set! week-start 0)
-               pos2))
-            ((#\V)
-             (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
-               (set! week-number-iso v)
-               pos2))
-            ((#\w)
-             (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
-               (set! week-day v)
-               pos2))
-            ((#\W)
-             (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
-               (set! week-number v)
-               (set! week-start 1)
-               pos2))
-            ((#\x) (priv:parse-template priv:LOCALE-SHORT-DATE-FORMAT pos))
-            ((#\X) (priv:parse-template priv:LOCALE-TIME-FORMAT pos))
-            ((#\y)
-             (receive (v pos2) (priv:read-number pos #f #f #f)
-               (set! year (priv:resolve-two-digit-year v))
-               pos2))
-            ((#\Y)
-             (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
-               (set! year v)
-               pos2))
-            ((#\z)
-             (receive (v pos2) (priv:parse-tz-offset pos)
-               (set! zone-offset v)
-               pos2))
-            ((#\Z) (error "Not Implement"))
-            ((#\1) (priv:parse-template "~Y-~m-~d" pos))
-            ((#\2) (priv:parse-template "~H:~M:~S~z" pos))
-            ((#\3) (priv:parse-template "~H:~M:~S" pos))
-            ((#\4) (priv:parse-template "~Y-~m-~dT~H:~M:~S~z" pos))
-            ((#\5) (priv:parse-template "~Y-~m-~dT~H:~M:~S" pos))
-            (else (priv:bad-format-error template-string))))
-
-        (define (priv:parse-template tmpl pos)
-          (let ((tlen (string-length tmpl)))
-            (let loop ((ti 0) (pos pos))
-              (if (>= ti tlen)
-                pos
-                (let ((ch (string-ref tmpl ti)))
-                  (if (char=? ch #\~)
-                    (let* ((ti1 (+ ti 1)))
-                      (when (>= ti1 tlen)
-                        (priv:bad-format-error tmpl))
-                      (let*
-                        ((next (string-ref tmpl ti1))
-                         (pad? (or (char=? next #\-) (char=? next #\_)))
-                         (dir (if pad?
-                                (begin
-                                  (when (>= (+ ti1 1) tlen)
-                                    (priv:bad-format-error tmpl))
-                                  (string-ref tmpl (+ ti1 1)))
-                                next))
-                         (pos2 (priv:parse-directive dir pos))
-                         (ti2 (if pad? (+ ti 3) (+ ti 2))))
-                        (loop ti2 pos2)))
-                    (begin
-                      (when (or (>= pos len)
-                                (not (char=? (string-ref input pos) ch)))
-                        (value-error "string->date: input does not match template"
-                                     (list input template-string)))
-                      (loop (+ ti 1) (+ pos 1)))))))))
-
-        (let ((pos (priv:parse-template template-string 0)))
-          (when (< pos len)
-            (value-error "string->date: input does not match template"
-                         (list input template-string)))
-
-          (let* ((year* (or year 0))
-                 (month* (or month 0))
-                 (day* (or day 0))
-                 (hour* (or hour 0))
-                 (minute* (or minute 0))
-                 (second* (or second 0))
-                 (nanosecond* (or nanosecond 0))
-                 (zone-offset* (or zone-offset 0)))
-
-            (when (and (not hour) hour12)
-              (let ((h (modulo hour12 12)))
-                (set! hour* (if (eq? ampm 'pm) (+ h 12) h))))
-
-            (when (and year-day (or (not month) (not day)))
-              (let ((days-in-year (if (priv:leap-year? year*) 366 365)))
-                (unless (and (integer? year-day)
-                             (<= 1 year-day days-in-year))
-                  (value-error "string->date: invalid day-of-year" input))
-                (receive (yy mm dd)
-                         (priv:civil-from-days
-                           (+ (priv:days-since-epoch year* 1 1)
-                              (- year-day 1)))
-                  (set! month* mm)
-                  (set! day* dd))))
-
-            (when (and (or (not month) (not day))
-                       week-number
-                       (integer? week-start)
-                       (integer? week-day))
-              (let*
-                ((wday-jan1 (priv:week-day 1 1 year*))
-                 (offset (modulo (- week-start wday-jan1) 7))
-                 (wday (modulo (- week-day week-start) 7))
-                 (yday (if (= week-number 0)
-                         (+ 1 (modulo (- week-day wday-jan1) 7))
-                         (+ 1 offset (* (- week-number 1) 7) wday)))
-                 (days-in-year (if (priv:leap-year? year*) 366 365)))
-                (unless (and (integer? yday)
-                             (<= 1 yday days-in-year))
-                  (value-error "string->date: invalid week number" input))
-                (receive (yy mm dd)
-                         (priv:civil-from-days
-                           (+ (priv:days-since-epoch year* 1 1)
-                              (- yday 1)))
-                  (set! month* mm)
-                  (set! day* dd))))
-
-            (when (and (or (not month) (not day))
-                       week-number-iso
-                       (integer? week-day))
-              (let*
-                ((iso-wday (if (= week-day 0) 7 week-day))
-                 (jan4-days (priv:days-since-epoch year* 1 4))
-                 (jan4-wday (priv:week-day 4 1 year*))
-                 (jan4-iso (if (= jan4-wday 0) 7 jan4-wday))
-                 (week1-monday (- jan4-days (- jan4-iso 1)))
-                 (target-days
-                   (+ week1-monday
-                      (* (- week-number-iso 1) 7)
-                      (- iso-wday 1))))
-                (receive (yy mm dd) (priv:civil-from-days target-days)
-                  (set! month* mm)
-                  (set! day* dd))))
-
-            (make-date nanosecond*
-                       second*
-                       minute*
-                       hour*
-                       day*
-                       month*
-                       year*
-                       zone-offset*)))))
+    ;
+    ; ;; ====================
+    ;
+    ; (define (priv:round-offset-to-minute offset)
+    ;   (let* ((sign (if (negative? offset) -1 1))
+    ;          (abs-off (abs offset))
+    ;          (q (quotient abs-off 60))
+    ;          (r (remainder abs-off 60)))
+    ;     (* sign (if (>= r 30) (+ q 1) q) 60)))
+    ;
+    ; (define (local-tz-offset)
+    ;   (let ((time-vec (g_datetime-now)))
+    ;     (if (and (vector? time-vec) (= (vector-length time-vec) 7))
+    ;       (let* ((year   (vector-ref time-vec 0))
+    ;              (month  (vector-ref time-vec 1))
+    ;              (day    (vector-ref time-vec 2))
+    ;              (hour   (vector-ref time-vec 3))
+    ;              (minute (vector-ref time-vec 4))
+    ;              (second (vector-ref time-vec 5)))
+    ;         (receive (utc-sec utc-usec) (glue:get-time-of-day)
+    ;           (let*
+    ;             ((days (priv:days-since-epoch year month day))
+    ;              (local-sec
+    ;                (+ (* days priv:SID)
+    ;                   (* hour 3600)
+    ;                   (* minute 60)
+    ;                   second))
+    ;              (offset (- local-sec utc-sec)))
+    ;             (priv:round-offset-to-minute offset))))
+    ;       0)))
+    ;
+    ; (define* (current-date (tz-offset (local-tz-offset)))
+    ;   (time-utc->date (current-time TIME-UTC) tz-offset))
+    ;
+    ; (define (current-julian-day)
+    ;   (error 'todo "TODO"))
+    ;
+    ; (define* (current-time (clock-type TIME-UTC))
+    ;   ((priv:query-time-dispatch clock-type cadr)))
+    ;
+    ; (define* (time-resolution (clock-type TIME-UTC))
+    ;   (priv:query-time-dispatch clock-type cddr))
+    ;
+    ; ;; ====================
+    ; ;; Date object and accessors
+    ; ;; ====================
+    ;
+    ; ;; Date objects are immutable once created
+    ; (define-record-type <date>
+    ;   (%make-date nanosecond second minute hour day month year zone-offset)
+    ;   date?
+    ;   (nanosecond  date-nanosecond)
+    ;   (second      date-second)
+    ;   (minute      date-minute)
+    ;   (hour        date-hour)
+    ;   (day         date-day)
+    ;   (month       date-month)
+    ;   (year        date-year)
+    ;   (zone-offset date-zone-offset))
+    ;
+    ; (define (make-date nanosecond second minute hour day month year zone-offset)
+    ;   ;; TODO: more guards maybe
+    ;   (unless (and (integer? nanosecond) (integer? second)
+    ;                (integer? minute)     (integer? hour)
+    ;                (integer? day)        (integer? month)
+    ;                (integer? year)       (integer? zone-offset))
+    ;     (error 'wrong-type-arg "The date fields need to be integer"))
+    ;   (%make-date nanosecond second minute hour day month year zone-offset))
+    ;
+    ; ;; ====================
+    ;
+    ; (define (priv:leap-year? year)
+    ;   (cond
+    ;     ((zero? (modulo year 400)) #t)
+    ;     ((zero? (modulo year 100)) #f)
+    ;     ((zero? (modulo year 4))   #t)
+    ;     (else                      #f)))
+    ;
+    ; (define priv:MONTH-ASSOC '((0 . 0)   (1 . 31)  (2 . 59)   (3 . 90)
+    ;                            (4 . 120) (5 . 151) (6 . 181)  (7 . 212)
+    ;                            (8 . 243) (9 . 273) (10 . 304) (11 . 334)))
+    ;
+    ; (define (priv:year-day day month year)
+    ;   (let ((days-pr (assoc (- month 1) priv:MONTH-ASSOC)))
+    ;     (unless days-pr
+    ;       (value-error "invalid month specified" month))
+    ;     ;; 闰2月，所以2月之后，且当年是闰年的，要多一天
+    ;     (if (and (priv:leap-year? year) (> month 2))
+    ;       (+ day (cdr days-pr) 1)
+    ;       (+ day (cdr days-pr)))))
+    ;
+    ; ;; ====================
+    ;
+    ; (define (priv:week-day day month year)
+    ;   (let* ((yy (if (negative? year) (+ year 1) year))
+    ;          (a (quotient (- 14 month) 12))
+    ;          (y (- yy a))
+    ;          (m (+ month (* 12 a) -2)))
+    ;     (modulo
+    ;       (+ day
+    ;          y
+    ;          (floor-quotient y 4)
+    ;          (- (floor-quotient y 100))
+    ;          (floor-quotient y 400)
+    ;          (floor-quotient (* 31 m) 12))
+    ;             7)))
+    ;
+    ; (define (priv:days-before-first-week date day-of-week-starting-week)
+    ;   (let*
+    ;     ((first-day
+    ;        (make-date 0 0 0 0
+    ;                   1
+    ;                   1
+    ;                   (date-year date)
+    ;                   0))
+    ;      (fdweek-day (date-week-day first-day)))
+    ;     (modulo (- day-of-week-starting-week fdweek-day)
+    ;             7)))
+    ;
+    ; (define (date-year-day date)
+    ;   (priv:year-day (date-day   date)
+    ;                  (date-month date)
+    ;                  (date-year  date)))
+    ;
+    ; (define (date-week-day date)
+    ;   (priv:week-day (date-day   date)
+    ;                  (date-month date)
+    ;                  (date-year  date)))
+    ;
+    ; (define (date-week-number date day-of-week-starting-week)
+    ;   (floor-quotient
+    ;     (- (date-year-day date)
+    ;        1
+    ;        (priv:days-before-first-week date day-of-week-starting-week))
+    ;     7))
+    ;
+    ; ;; ====================
+    ; ;; Time/Date/Julian Day/Modified Julian Day Converters
+    ; ;; ====================
+    ;
+    ; (define (priv:tai->utc-seconds tai-sec)
+    ;   (let lp ((table priv:leap-second-table))
+    ;     (cond
+    ;       ((null? table) (- tai-sec 10))
+    ;       (else
+    ;         (let* ((utc-start (caar table))
+    ;                (delta (cdar table))
+    ;                (tai-start (+ utc-start delta)))
+    ;           (if (>= tai-sec tai-start)
+    ;             (- tai-sec delta)
+    ;             (lp (cdr table))))))))
+    ;
+    ; (define (time-utc->time-tai time-utc)
+    ;   (unless (and (time? time-utc) (eq? (time-type time-utc) TIME-UTC))
+    ;     (error 'wrong-type-arg "time-utc->time-tai: time-utc must be a TIME-UTC object" time-utc))
+    ;   (make-time TIME-TAI
+    ;              (time-nanosecond time-utc)
+    ;              (+ (time-second time-utc)
+    ;                 (priv:leap-second-delta (time-second time-utc)))))
+    ;
+    ; (define (time-tai->time-utc time-tai)
+    ;   (unless (and (time? time-tai) (eq? (time-type time-tai) TIME-TAI))
+    ;     (error 'wrong-type-arg "time-tai->time-utc: time-tai must be a TIME-TAI object" time-tai))
+    ;   (make-time TIME-UTC
+    ;              (time-nanosecond time-tai)
+    ;              (priv:tai->utc-seconds (time-second time-tai))))
+    ;
+    ; (define (time-utc->time-monotonic time-utc)
+    ;   (unless (and (time? time-utc) (eq? (time-type time-utc) TIME-UTC))
+    ;     (error 'wrong-type-arg "time-utc->time-monotonic: time-utc must be a TIME-UTC object" time-utc))
+    ;   (make-time TIME-MONOTONIC
+    ;              (time-nanosecond time-utc)
+    ;              (time-second time-utc)))
+    ;
+    ; (define (time-monotonic->time-utc time-monotonic)
+    ;   (unless (and (time? time-monotonic)
+    ;                (eq? (time-type time-monotonic) TIME-MONOTONIC))
+    ;     (error 'wrong-type-arg
+    ;            "time-monotonic->time-utc: time-monotonic must be a TIME-MONOTONIC object"
+    ;            time-monotonic))
+    ;   (make-time TIME-UTC
+    ;              (time-nanosecond time-monotonic)
+    ;              (time-second time-monotonic)))
+    ;
+    ; (define (time-tai->time-monotonic time-tai)
+    ;   (unless (and (time? time-tai) (eq? (time-type time-tai) TIME-TAI))
+    ;     (error 'wrong-type-arg
+    ;            "time-tai->time-monotonic: time-tai must be a TIME-TAI object"
+    ;            time-tai))
+    ;   (time-utc->time-monotonic (time-tai->time-utc time-tai)))
+    ;
+    ; (define (time-monotonic->time-tai time-monotonic)
+    ;   (unless (and (time? time-monotonic)
+    ;                (eq? (time-type time-monotonic) TIME-MONOTONIC))
+    ;     (error 'wrong-type-arg
+    ;            "time-monotonic->time-tai: time-monotonic must be a TIME-MONOTONIC object"
+    ;            time-monotonic))
+    ;   (time-utc->time-tai (time-monotonic->time-utc time-monotonic)))
+    ;
+    ; (define (priv:days-since-epoch year month day)
+    ;   ;; Howard Hinnant's days_from_civil algorithm, inverse of civil-from-days
+    ;   (let*
+    ;     ((y (- year (if (<= month 2) 1 0)))
+    ;      (era (if (>= y 0)
+    ;             (floor-quotient y 400)
+    ;             (floor-quotient (- y 399) 400)))
+    ;      (yoe (- y (* era 400)))
+    ;      (m (+ month (if (> month 2) -3 9))) ; March=0, ..., February=11
+    ;      (doy (+ (floor-quotient (+ (* 153 m) 2) 5) (- day 1)))
+    ;      (doe
+    ;        (+ (* yoe 365)
+    ;           (floor-quotient yoe 4)
+    ;           (- (floor-quotient yoe 100))
+    ;           doy)))
+    ;     (- (+ (* era 146097) doe) 719468)))
+    ;
+    ; (define (priv:civil-from-days days)
+    ;   ;; Howard Hinnant's algorithm, adapted for proleptic Gregorian calendar
+    ;   (let*
+    ;     ((z (+ days 719468))
+    ;      (era (if (>= z 0)
+    ;             (floor-quotient z 146097)
+    ;             (floor-quotient (- z 146096) 146097)))
+    ;      (doe (- z (* era 146097))) ; [0, 146096]
+    ;      (yoe
+    ;        (floor-quotient (- doe (floor-quotient doe 1460)
+    ;                          (- (floor-quotient doe 36524))
+    ;                          (floor-quotient doe 146096))
+    ;                        365))
+    ;      (y (+ yoe (* era 400)))
+    ;      (doy
+    ;        (- doe (+ (* 365 yoe)
+    ;                  (floor-quotient yoe 4)
+    ;                  (- (floor-quotient yoe 100)))))
+    ;      (mp (floor-quotient (+ (* 5 doy) 2) 153))
+    ;      (d (+ (- doy (floor-quotient (+ (* 153 mp) 2) 5)) 1))
+    ;      (m (+ mp (if (< mp 10) 3 -9)))
+    ;      (y (if (<= m 2) (+ y 1) y)))
+    ;     (values y m d)))
+    ;
+    ; ;; Default tz-offset uses local time zone from OS.
+    ; (define* (time-utc->date time-utc (tz-offset (local-tz-offset)))
+    ;   (unless (and (time? time-utc) (eq? (time-type time-utc) TIME-UTC))
+    ;     (error 'wrong-type-arg "time-utc->date: time-utc must be a TIME-UTC object" time-utc))
+    ;   (unless (integer? tz-offset)
+    ;     (error 'wrong-type-arg "time-utc->date: tz-offset must be an integer" tz-offset))
+    ;   (let* ((sec (+ (time-second time-utc) tz-offset))
+    ;          (nsec (time-nanosecond time-utc)))
+    ;     (receive (days day-sec) (floor/ sec priv:SID)
+    ;       (receive (year month day) (priv:civil-from-days days)
+    ;         (receive (hour rem1) (floor/ day-sec 3600)
+    ;           (receive (minute second) (floor/ rem1 60)
+    ;             (make-date nsec second minute hour day month year tz-offset)))))))
+    ;
+    ; (define (date->time-utc date)
+    ;   (unless (date? date)
+    ;     (error 'wrong-type-arg "date->time-utc: date must be a date object" date))
+    ;   (let*
+    ;     ((days
+    ;        (priv:days-since-epoch (date-year date)
+    ;                               (date-month date)
+    ;                               (date-day date)))
+    ;      (local-sec
+    ;        (+ (* days priv:SID)
+    ;           (* (date-hour date) 3600)
+    ;           (* (date-minute date) 60)
+    ;           (date-second date)))
+    ;      (utc-sec (- local-sec (date-zone-offset date))))
+    ;     (make-time TIME-UTC (date-nanosecond date) utc-sec)))
+    ;
+    ; ;; Default tz-offset uses local time zone from OS.
+    ; (define* (time-tai->date time-tai (tz-offset (local-tz-offset)))
+    ;   (unless (and (time? time-tai) (eq? (time-type time-tai) TIME-TAI))
+    ;     (error 'wrong-type-arg "time-tai->date: time-tai must be a TIME-TAI object" time-tai))
+    ;   (unless (integer? tz-offset)
+    ;     (error 'wrong-type-arg "time-tai->date: tz-offset must be an integer" tz-offset))
+    ;   (time-utc->date (time-tai->time-utc time-tai) tz-offset))
+    ;
+    ; (define (date->time-tai date)
+    ;   (time-utc->time-tai (date->time-utc date)))
+    ;
+    ; ;; Default tz-offset uses local time zone from OS.
+    ; (define* (time-monotonic->date time-monotonic (tz-offset (local-tz-offset)))
+    ;   (unless (and (time? time-monotonic)
+    ;                (eq? (time-type time-monotonic) TIME-MONOTONIC))
+    ;     (error 'wrong-type-arg
+    ;            "time-monotonic->date: time-monotonic must be a TIME-MONOTONIC object"
+    ;            time-monotonic))
+    ;   (unless (integer? tz-offset)
+    ;     (error 'wrong-type-arg "time-monotonic->date: tz-offset must be an integer" tz-offset))
+    ;   (time-utc->date (time-monotonic->time-utc time-monotonic) tz-offset))
+    ;
+    ; (define (date->time-monotonic date)
+    ;   (unless (date? date)
+    ;     (error 'wrong-type-arg "date->time-monotonic: date must be a date object" date))
+    ;   (time-utc->time-monotonic (date->time-utc date)))
+    ;
+    ; (define (date->julian-day date)
+    ;   (unless (date? date)
+    ;     (error 'wrong-type-arg "date->julian-day: date must be a date object" date))
+    ;   (let* ((t (time-utc->time-monotonic (date->time-utc date)))
+    ;          (secs (time-second t))
+    ;          (nsecs (time-nanosecond t))
+    ;          (total-secs (+ secs (/ nsecs priv:NANO))))
+    ;     (+ priv:TAI-EPOCH-IN-JD (/ total-secs priv:SID))))
+    ;
+    ; (define (date->modified-julian-day date)
+    ;   (- (date->julian-day date) 4800001/2))
+    ;
+    ; ;; ====================
+    ; ;; Date to String/String to Date Converters
+    ; ;; ====================
+    ;
+    ; (define (priv:locale-abbr-weekday n)
+    ;   (vector-ref priv:LOCALE-ABBR-WEEKDAY-VECTOR n))
+    ; (define (priv:locale-long-weekday n)
+    ;   (vector-ref priv:LOCALE-LONG-WEEKDAY-VECTOR n))
+    ; (define (priv:locale-abbr-month n)
+    ;   (vector-ref priv:LOCALE-ABBR-MONTH-VECTOR n))
+    ; (define (priv:locale-long-month n)
+    ;   (vector-ref priv:LOCALE-LONG-MONTH-VECTOR n))
+    ;
+    ; ;; Only handles positive integers `n`. Internal use only.
+    ; (define (priv:padding n pad-with len)
+    ;   (let* ((str     (number->string n))
+    ;          (str-len (string-length str)))
+    ;     (cond
+    ;       ((or (> str-len len) (not pad-with)) str)
+    ;       (else (string-pad str len pad-with)))))
+    ;
+    ; (define (priv:locale-am/pm hr)
+    ;   (if (> hr 11) priv:LOCALE-PM priv:LOCALE-AM))
+    ;
+    ; (define (priv:date-week-number-iso date)
+    ;   (let* ((year (date-year date))
+    ;          (jan1-wday (priv:week-day 1 1 year))
+    ;          (offset (if (> jan1-wday 4) 0 1))
+    ;          ;; 调整值：补偿 1-based 和 周日归属
+    ;          (adjusted (+ (date-year-day date) jan1-wday -2))
+    ;          (raw-week (+ (floor-quotient adjusted 7) offset)))
+    ;     (cond
+    ;       ((zero? raw-week)
+    ;        (priv:date-week-number-iso 
+    ;         (make-date 0 0 0 0 31 12 (- year 1) 0)))
+    ;
+    ;       ((and (= raw-week 53)
+    ;             (<= (priv:week-day 1 1 (+ year 1)) 4))
+    ;        1)
+    ;
+    ;       (else raw-week))))
+    ;
+    ; (define (priv:last-n-digits i n)
+    ;   (modulo i (expt 10 n)))
+    ;
+    ; (define (priv:tz-printer offset port)
+    ;   (cond
+    ;     ((zero? offset)     (display "Z" port))
+    ;     ((negative? offset) (display "-" port))
+    ;     (else               (display "+" port)))
+    ;   (unless (zero? offset)
+    ;     (let ((hours   (abs (quotient offset (* 60 60))))
+    ;           (minutes (abs (quotient (remainder offset (* 60 60)) 60))))
+    ;       (display (priv:padding hours   #\0 2) port)
+    ;       (display (priv:padding minutes #\0 2) port))))
+    ;
+    ; (define (priv:directives/formatter char format-string)
+    ;   (lambda (date pad-with port)
+    ;     (case char
+    ;       ((#\~) (display #\~ port))
+    ;       ((#\a)
+    ;        (display (priv:locale-abbr-weekday (date-week-day date))
+    ;                 port))
+    ;       ((#\A)
+    ;        (display (priv:locale-long-weekday (date-week-day date))
+    ;                 port))
+    ;       ((#\b #\h)
+    ;        (display (priv:locale-abbr-month (date-month date))
+    ;                 port))
+    ;       ((#\B)
+    ;        (display (priv:locale-long-month (date-month date))
+    ;                 port))
+    ;       ((#\c)
+    ;        (display (date->string date priv:LOCALE-DATE-TIME-FORMAT)
+    ;                 port))
+    ;       ((#\d)
+    ;        (display (priv:padding (date-day date) #\0 2)
+    ;                 port))
+    ;       ((#\D)
+    ;        (display (date->string date "~m/~d/~y")
+    ;                 port))
+    ;       ((#\e)
+    ;        (display (priv:padding (date-day date) #\space 2)
+    ;                 port))
+    ;       ;; ref Guile
+    ;       ((#\f)
+    ;        (receive (s ns)
+    ;                 (floor/ (+ (* (date-second date) priv:NANO)
+    ;                            (date-nanosecond date))
+    ;                         priv:NANO)
+    ;          (display (number->string s) port)
+    ;          (display priv:LOCALE-DECIMAL-POINT port)
+    ;          (let ((str (priv:padding ns #\0 9)))
+    ;            (display (substring str 0 1) port)
+    ;            (display (string-trim-right str #\0 1) port))))
+    ;       ((#\H)
+    ;        (display (priv:padding (date-hour date)
+    ;                               pad-with 2)
+    ;                 port))
+    ;       ((#\I)
+    ;        (display (priv:padding (+ 1 (modulo (- (date-hour date) 1) 12))
+    ;                               pad-with
+    ;                               2)
+    ;                 port))
+    ;       ((#\j)
+    ;        (display (priv:padding (date-year-day date)
+    ;                               pad-with 3)
+    ;                 port))
+    ;       ((#\k)
+    ;        (display (priv:padding (date-hour date)
+    ;                               #\space 2)
+    ;                 port))
+    ;       ((#\l)
+    ;        (display (priv:padding (+ 1 (modulo (- (date-hour date) 1) 12))
+    ;                               #\space
+    ;                               2)
+    ;                 port))
+    ;       ((#\m)
+    ;        (display (priv:padding (date-month date)
+    ;                               pad-with 2)
+    ;                 port))
+    ;       ((#\M)
+    ;        (display (priv:padding (date-minute date)
+    ;                               pad-with 2)
+    ;                 port))
+    ;       ((#\n) (newline port))
+    ;       ((#\N)
+    ;        (display (priv:padding (date-nanosecond date)
+    ;                               pad-with 9)
+    ;                 port))
+    ;       ((#\p) (display (priv:locale-am/pm (date-hour date)) port))
+    ;       ((#\r) (display (date->string date "~I:~M:~S ~p") port))
+    ;
+    ;       ((#\s) (error "Not Implement"))
+    ;       ((#\S)
+    ;        (let ((sec-delta (if (> (date-nanosecond date) priv:NANO)
+    ;                           1 0)))
+    ;          (display
+    ;            (priv:padding (+ (date-second date) sec-delta)
+    ;                          pad-with 2)
+    ;                   port)))
+    ;
+    ;       ((#\t) (display #\tab port))
+    ;       ((#\T) (display (date->string date "~H:~M:~S") port))
+    ;       ((#\U)
+    ;        (let* ((week>0?   (> (priv:days-before-first-week date 0) 0))
+    ;               (week-num  (date-week-number date 0))
+    ;               (week-num* (if week>0? (+ week-num 1) week-num)))
+    ;          (display (priv:padding week-num* #\0 2) port)))
+    ;
+    ;       ((#\V)
+    ;        (display (priv:padding (priv:date-week-number-iso date)
+    ;                               #\0 2) port))
+    ;       ((#\w) (display (date-week-day date) port))
+    ;       ((#\W)
+    ;        (let* ((week>1?   (> (priv:days-before-first-week date 1) 0))
+    ;               (week-num  (date-week-number date 1))
+    ;               (week-num* (if week>1? (+ week-num 1) week-num)))
+    ;          (display (priv:padding week-num* #\0 2) port)))
+    ;       ((#\x) (display (date->string date priv:LOCALE-SHORT-DATE-FORMAT) port))
+    ;       ((#\X) (display (date->string date priv:LOCALE-TIME-FORMAT) port))
+    ;       ((#\y)
+    ;        (display (priv:padding (priv:last-n-digits (date-year date) 2)
+    ;                               pad-with 2)
+    ;                 port))
+    ;       ((#\Y)
+    ;        (display (priv:padding (date-year date) pad-with 4)
+    ;                 port))
+    ;       ((#\z) (priv:tz-printer (date-zone-offset date) port))
+    ;       ((#\Z) (error "Not Implement"))
+    ;       ((#\1) (display (date->string date "~Y-~m-~d") port))
+    ;       ((#\2) (display (date->string date "~H:~M:~S~z") port))
+    ;       ((#\3) (display (date->string date "~H:~M:~S") port))
+    ;       ((#\4) (display (date->string date "~Y-~m-~dT~H:~M:~S~z") port))
+    ;       ((#\5) (display (date->string date "~Y-~m-~dT~H:~M:~S") port))
+    ;       (else (priv:bad-format-error format-string)))))
+    ;
+    ; (define (priv:bad-format-error format-string)
+    ;   (value-error "bad date format string" format-string))
+    ;
+    ; (define (priv:date-printer date format-string format-string-port port)
+    ;   (let ((current-char (read-char format-string-port))
+    ;         (pad-char     (peek-char format-string-port)))
+    ;     (cond
+    ;       ((eof-object? current-char) (values))
+    ;
+    ;       ((and (eof-object? pad-char)
+    ;             ;; unfinished directives
+    ;             (char=? current-char #\~))
+    ;        (priv:bad-format-error format-string))
+    ;
+    ;       ((and (char=? current-char #\~)
+    ;             (or (char=? pad-char #\-) (char=? pad-char #\_)))
+    ;        (let ((pad-pad-char (begin (read-char format-string-port)
+    ;                                   (peek-char format-string-port))))
+    ;          (if (eof-object? pad-pad-char)
+    ;            (priv:bad-format-error format-string)
+    ;            (let ((formatter (priv:directives/formatter pad-pad-char format-string))
+    ;                  (pad-with  (if (char=? pad-char #\-) #f #\space)))
+    ;              (begin (formatter date pad-with port)
+    ;                     (priv:date-printer date format-string
+    ;                                        format-string-port port))))))
+    ;
+    ;       ((char=? current-char #\~)
+    ;        (let ((formatter (priv:directives/formatter pad-char format-string)))
+    ;          (begin (formatter date #\0 port)
+    ;                 (read-char format-string-port) ; consume
+    ;                 (priv:date-printer date format-string
+    ;                                    format-string-port port))))
+    ;
+    ;       (else
+    ;         (display current-char port)
+    ;         (priv:date-printer date format-string
+    ;                            format-string-port port)))))
+    ;
+    ; (define* (date->string date (format-string "~c"))
+    ;   (let ((str-port (open-output-string)))
+    ;     (priv:date-printer date format-string
+    ;                (open-input-string format-string)
+    ;                str-port)
+    ;     (get-output-string str-port)))
+    ;
+    ; (define (priv:string-ci-prefix? str pos prefix)
+    ;   (let* ((plen (string-length prefix))
+    ;          (slen (string-length str)))
+    ;     (and (<= (+ pos plen) slen)
+    ;          (let loop ((i 0))
+    ;            (cond
+    ;              ((= i plen) #t)
+    ;              ((char=? (char-downcase (string-ref str (+ pos i)))
+    ;                       (char-downcase (string-ref prefix i)))
+    ;               (loop (+ i 1)))
+    ;              (else #f))))))
+    ;
+    ; (define (priv:skip-to pred str pos)
+    ;   (let ((len (string-length str)))
+    ;     (let loop ((i pos))
+    ;       (cond
+    ;         ((>= i len)
+    ;          (value-error "string->date: input does not match template" str))
+    ;         ((pred (string-ref str i)) i)
+    ;         (else (loop (+ i 1)))))))
+    ;
+    ; (define (priv:read-digits str pos)
+    ;   (let ((len (string-length str)))
+    ;     (let loop ((i pos))
+    ;       (if (and (< i len) (char-numeric? (string-ref str i)))
+    ;         (loop (+ i 1))
+    ;         (if (= i pos)
+    ;           (value-error "string->date: expected digits" str)
+    ;           (values (substring str pos i) i))))))
+    ;
+    ; (define (priv:read-fixed-digits str pos n)
+    ;   (let ((end (+ pos n))
+    ;         (len (string-length str)))
+    ;     (when (> end len)
+    ;       (value-error "string->date: expected digits" str))
+    ;     (let loop ((i pos))
+    ;       (if (= i end)
+    ;         (values (substring str pos end) end)
+    ;         (if (char-numeric? (string-ref str i))
+    ;           (loop (+ i 1))
+    ;           (value-error "string->date: expected digits" str))))))
+    ;
+    ; (define (priv:match-locale str pos vec)
+    ;   (let ((len (vector-length vec)))
+    ;     (let loop ((i 0) (best-index #f) (best-len 0))
+    ;       (if (= i len)
+    ;         (if best-index
+    ;           (values best-index (+ pos best-len))
+    ;           (value-error "string->date: invalid locale name" str))
+    ;         (let ((name (vector-ref vec i)))
+    ;           (if (and (string? name)
+    ;                    (> (string-length name) 0)
+    ;                    (priv:string-ci-prefix? str pos name))
+    ;             (let ((nlen (string-length name)))
+    ;               (if (> nlen best-len)
+    ;                 (loop (+ i 1) i nlen)
+    ;                 (loop (+ i 1) best-index best-len)))
+    ;             (loop (+ i 1) best-index best-len)))))))
+    ;
+    ; (define (string->date input-string template-string)
+    ;   (unless (and (string? input-string) (string? template-string))
+    ;     (error 'wrong-type-arg
+    ;            "string->date: input-string and template-string must be strings"
+    ;            (list input-string template-string)))
+    ;   (let* ((input input-string)
+    ;          (len (string-length input))
+    ;          (year #f)
+    ;          (month #f)
+    ;          (day #f)
+    ;          (hour #f)
+    ;          (minute #f)
+    ;          (second #f)
+    ;          (nanosecond #f)
+    ;          (zone-offset #f)
+    ;          (year-day #f)
+    ;          (week-day #f)
+    ;          (week-number #f)
+    ;          (week-start #f)
+    ;          (week-number-iso #f)
+    ;          (hour12 #f)
+    ;          (ampm #f))
+    ;
+    ;     (define (priv:expect-char pos ch)
+    ;       (if (and (< pos len) (char=? (string-ref input pos) ch))
+    ;         (+ pos 1)
+    ;         (value-error "string->date: input does not match template"
+    ;                      (list input template-string))))
+    ;
+    ;     (define (priv:read-number pos skip-pred allow-space? allow-sign?)
+    ;       (let*
+    ;         ((pos (if skip-pred (priv:skip-to skip-pred input pos) pos))
+    ;          (pos (if (and allow-space?
+    ;                        (< pos len)
+    ;                        (char=? (string-ref input pos) #\space))
+    ;                 (+ pos 1)
+    ;                 pos))
+    ;          (start pos)
+    ;          (pos (if (and allow-sign?
+    ;                        (< pos len)
+    ;                        (or (char=? (string-ref input pos) #\+)
+    ;                            (char=? (string-ref input pos) #\-)))
+    ;                 (+ pos 1)
+    ;                 pos)))
+    ;         (receive (digits end) (priv:read-digits input pos)
+    ;           (values (string->number (substring input start end)) end))))
+    ;
+    ;     (define (priv:parse-tz-offset pos)
+    ;       (cond
+    ;         ((and (< pos len) (char=? (string-ref input pos) #\Z))
+    ;          (values 0 (+ pos 1)))
+    ;         ((and (< pos len)
+    ;               (or (char=? (string-ref input pos) #\+)
+    ;                   (char=? (string-ref input pos) #\-)))
+    ;          (let* ((sign (if (char=? (string-ref input pos) #\-) -1 1))
+    ;                 (pos (+ pos 1)))
+    ;            (receive (hh pos1) (priv:read-fixed-digits input pos 2)
+    ;              (let ((pos2 pos1))
+    ;                (if (and (< pos2 len) (char=? (string-ref input pos2) #\:))
+    ;                  (set! pos2 (+ pos2 1)))
+    ;                (receive (mm pos3) (priv:read-fixed-digits input pos2 2)
+    ;                  (values (* sign (+ (* (string->number hh) 3600)
+    ;                                     (* (string->number mm) 60)))
+    ;                          pos3))))))
+    ;         (else
+    ;          (value-error "string->date: invalid time zone offset" input))))
+    ;
+    ;     (define (priv:resolve-two-digit-year y)
+    ;       (let* ((y2 (modulo y 100))
+    ;              (cur-year (date-year (current-date 0)))
+    ;              (century (* (quotient cur-year 100) 100))
+    ;              (candidate (+ century y2)))
+    ;         (cond
+    ;           ((< candidate (- cur-year 50)) (+ candidate 100))
+    ;           ((> candidate (+ cur-year 49)) (- candidate 100))
+    ;           (else candidate))))
+    ;
+    ;     (define (priv:parse-directive dir pos)
+    ;       (case dir
+    ;         ((#\~) (priv:expect-char pos #\~))
+    ;         ((#\n) (priv:expect-char pos #\newline))
+    ;         ((#\t) (priv:expect-char pos #\tab))
+    ;         ((#\a)
+    ;          (let ((pos (priv:skip-to char-alphabetic? input pos)))
+    ;            (receive
+    ;              (idx pos2) (priv:match-locale input pos
+    ;                                           priv:LOCALE-ABBR-WEEKDAY-VECTOR)
+    ;              pos2)))
+    ;         ((#\A)
+    ;          (let ((pos (priv:skip-to char-alphabetic? input pos)))
+    ;            (receive
+    ;              (idx pos2) (priv:match-locale input pos
+    ;                                           priv:LOCALE-LONG-WEEKDAY-VECTOR)
+    ;              pos2)))
+    ;         ((#\b #\h)
+    ;          (let ((pos (priv:skip-to char-alphabetic? input pos)))
+    ;            (receive
+    ;              (idx pos2) (priv:match-locale input pos
+    ;                                           priv:LOCALE-ABBR-MONTH-VECTOR)
+    ;              (set! month idx)
+    ;              pos2)))
+    ;         ((#\B)
+    ;          (let ((pos (priv:skip-to char-alphabetic? input pos)))
+    ;            (receive
+    ;              (idx pos2) (priv:match-locale input pos
+    ;                                           priv:LOCALE-LONG-MONTH-VECTOR)
+    ;              (set! month idx)
+    ;              pos2)))
+    ;         ((#\c) (priv:parse-template priv:LOCALE-DATE-TIME-FORMAT pos))
+    ;         ((#\D) (priv:parse-template "~m/~d/~y" pos))
+    ;         ((#\d)
+    ;          (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
+    ;            (set! day v)
+    ;            pos2))
+    ;         ((#\e)
+    ;          (receive (v pos2) (priv:read-number pos #f #t #f)
+    ;            (set! day v)
+    ;            pos2))
+    ;         ((#\f)
+    ;          (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
+    ;            (set! second v)
+    ;            (let ((pos3 pos2))
+    ;              (if (and (< pos3 len)
+    ;                       (char=? (string-ref input pos3)
+    ;                               (string-ref priv:LOCALE-DECIMAL-POINT 0)))
+    ;                (begin
+    ;                  (set! pos3 (+ pos3 1))
+    ;                  (receive (frac pos4) (priv:read-digits input pos3)
+    ;                    (let ((flen (string-length frac)))
+    ;                      (when (> flen 9)
+    ;                        (value-error "string->date: invalid fractional seconds" input))
+    ;                      (set! nanosecond
+    ;                            (* (string->number frac) (expt 10 (- 9 flen)))))
+    ;                    pos4))
+    ;                (begin
+    ;                  (set! nanosecond 0)
+    ;                  pos3)))))
+    ;         ((#\H)
+    ;          (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
+    ;            (set! hour v)
+    ;            pos2))
+    ;         ((#\I)
+    ;          (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
+    ;            (set! hour12 v)
+    ;            pos2))
+    ;         ((#\j)
+    ;          (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
+    ;            (set! year-day v)
+    ;            pos2))
+    ;         ((#\k)
+    ;          (receive (v pos2) (priv:read-number pos #f #t #f)
+    ;            (set! hour v)
+    ;            pos2))
+    ;         ((#\l)
+    ;          (receive (v pos2) (priv:read-number pos #f #t #f)
+    ;            (set! hour12 v)
+    ;            pos2))
+    ;         ((#\m)
+    ;          (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
+    ;            (set! month v)
+    ;            pos2))
+    ;         ((#\M)
+    ;          (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
+    ;            (set! minute v)
+    ;            pos2))
+    ;         ((#\N)
+    ;          (let ((pos (priv:skip-to char-numeric? input pos)))
+    ;            (receive (digits pos2) (priv:read-digits input pos)
+    ;              (when (> (string-length digits) 9)
+    ;                (value-error "string->date: invalid nanosecond" input))
+    ;              (set! nanosecond (string->number digits))
+    ;              pos2)))
+    ;         ((#\p)
+    ;          (let ((pos (priv:skip-to char-alphabetic? input pos)))
+    ;            (cond
+    ;              ((priv:string-ci-prefix? input pos priv:LOCALE-AM)
+    ;               (set! ampm 'am)
+    ;               (+ pos (string-length priv:LOCALE-AM)))
+    ;              ((priv:string-ci-prefix? input pos priv:LOCALE-PM)
+    ;               (set! ampm 'pm)
+    ;               (+ pos (string-length priv:LOCALE-PM)))
+    ;              (else
+    ;               (value-error "string->date: invalid am/pm" input)))))
+    ;         ((#\r) (priv:parse-template "~I:~M:~S ~p" pos))
+    ;         ((#\s) (error "Not Implement"))
+    ;         ((#\S)
+    ;          (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
+    ;            (set! second v)
+    ;            pos2))
+    ;         ((#\T) (priv:parse-template "~H:~M:~S" pos))
+    ;         ((#\U)
+    ;          (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
+    ;            (set! week-number v)
+    ;            (set! week-start 0)
+    ;            pos2))
+    ;         ((#\V)
+    ;          (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
+    ;            (set! week-number-iso v)
+    ;            pos2))
+    ;         ((#\w)
+    ;          (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
+    ;            (set! week-day v)
+    ;            pos2))
+    ;         ((#\W)
+    ;          (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
+    ;            (set! week-number v)
+    ;            (set! week-start 1)
+    ;            pos2))
+    ;         ((#\x) (priv:parse-template priv:LOCALE-SHORT-DATE-FORMAT pos))
+    ;         ((#\X) (priv:parse-template priv:LOCALE-TIME-FORMAT pos))
+    ;         ((#\y)
+    ;          (receive (v pos2) (priv:read-number pos #f #f #f)
+    ;            (set! year (priv:resolve-two-digit-year v))
+    ;            pos2))
+    ;         ((#\Y)
+    ;          (receive (v pos2) (priv:read-number pos char-numeric? #f #f)
+    ;            (set! year v)
+    ;            pos2))
+    ;         ((#\z)
+    ;          (receive (v pos2) (priv:parse-tz-offset pos)
+    ;            (set! zone-offset v)
+    ;            pos2))
+    ;         ((#\Z) (error "Not Implement"))
+    ;         ((#\1) (priv:parse-template "~Y-~m-~d" pos))
+    ;         ((#\2) (priv:parse-template "~H:~M:~S~z" pos))
+    ;         ((#\3) (priv:parse-template "~H:~M:~S" pos))
+    ;         ((#\4) (priv:parse-template "~Y-~m-~dT~H:~M:~S~z" pos))
+    ;         ((#\5) (priv:parse-template "~Y-~m-~dT~H:~M:~S" pos))
+    ;         (else (priv:bad-format-error template-string))))
+    ;
+    ;     (define (priv:parse-template tmpl pos)
+    ;       (let ((tlen (string-length tmpl)))
+    ;         (let loop ((ti 0) (pos pos))
+    ;           (if (>= ti tlen)
+    ;             pos
+    ;             (let ((ch (string-ref tmpl ti)))
+    ;               (if (char=? ch #\~)
+    ;                 (let* ((ti1 (+ ti 1)))
+    ;                   (when (>= ti1 tlen)
+    ;                     (priv:bad-format-error tmpl))
+    ;                   (let*
+    ;                     ((next (string-ref tmpl ti1))
+    ;                      (pad? (or (char=? next #\-) (char=? next #\_)))
+    ;                      (dir (if pad?
+    ;                             (begin
+    ;                               (when (>= (+ ti1 1) tlen)
+    ;                                 (priv:bad-format-error tmpl))
+    ;                               (string-ref tmpl (+ ti1 1)))
+    ;                             next))
+    ;                      (pos2 (priv:parse-directive dir pos))
+    ;                      (ti2 (if pad? (+ ti 3) (+ ti 2))))
+    ;                     (loop ti2 pos2)))
+    ;                 (begin
+    ;                   (when (or (>= pos len)
+    ;                             (not (char=? (string-ref input pos) ch)))
+    ;                     (value-error "string->date: input does not match template"
+    ;                                  (list input template-string)))
+    ;                   (loop (+ ti 1) (+ pos 1)))))))))
+    ;
+    ;     (let ((pos (priv:parse-template template-string 0)))
+    ;       (when (< pos len)
+    ;         (value-error "string->date: input does not match template"
+    ;                      (list input template-string)))
+    ;
+    ;       (let* ((year* (or year 0))
+    ;              (month* (or month 0))
+    ;              (day* (or day 0))
+    ;              (hour* (or hour 0))
+    ;              (minute* (or minute 0))
+    ;              (second* (or second 0))
+    ;              (nanosecond* (or nanosecond 0))
+    ;              (zone-offset* (or zone-offset 0)))
+    ;
+    ;         (when (and (not hour) hour12)
+    ;           (let ((h (modulo hour12 12)))
+    ;             (set! hour* (if (eq? ampm 'pm) (+ h 12) h))))
+    ;
+    ;         (when (and year-day (or (not month) (not day)))
+    ;           (let ((days-in-year (if (priv:leap-year? year*) 366 365)))
+    ;             (unless (and (integer? year-day)
+    ;                          (<= 1 year-day days-in-year))
+    ;               (value-error "string->date: invalid day-of-year" input))
+    ;             (receive (yy mm dd)
+    ;                      (priv:civil-from-days
+    ;                        (+ (priv:days-since-epoch year* 1 1)
+    ;                           (- year-day 1)))
+    ;               (set! month* mm)
+    ;               (set! day* dd))))
+    ;
+    ;         (when (and (or (not month) (not day))
+    ;                    week-number
+    ;                    (integer? week-start)
+    ;                    (integer? week-day))
+    ;           (let*
+    ;             ((wday-jan1 (priv:week-day 1 1 year*))
+    ;              (offset (modulo (- week-start wday-jan1) 7))
+    ;              (wday (modulo (- week-day week-start) 7))
+    ;              (yday (if (= week-number 0)
+    ;                      (+ 1 (modulo (- week-day wday-jan1) 7))
+    ;                      (+ 1 offset (* (- week-number 1) 7) wday)))
+    ;              (days-in-year (if (priv:leap-year? year*) 366 365)))
+    ;             (unless (and (integer? yday)
+    ;                          (<= 1 yday days-in-year))
+    ;               (value-error "string->date: invalid week number" input))
+    ;             (receive (yy mm dd)
+    ;                      (priv:civil-from-days
+    ;                        (+ (priv:days-since-epoch year* 1 1)
+    ;                           (- yday 1)))
+    ;               (set! month* mm)
+    ;               (set! day* dd))))
+    ;
+    ;         (when (and (or (not month) (not day))
+    ;                    week-number-iso
+    ;                    (integer? week-day))
+    ;           (let*
+    ;             ((iso-wday (if (= week-day 0) 7 week-day))
+    ;              (jan4-days (priv:days-since-epoch year* 1 4))
+    ;              (jan4-wday (priv:week-day 4 1 year*))
+    ;              (jan4-iso (if (= jan4-wday 0) 7 jan4-wday))
+    ;              (week1-monday (- jan4-days (- jan4-iso 1)))
+    ;              (target-days
+    ;                (+ week1-monday
+    ;                   (* (- week-number-iso 1) 7)
+    ;                   (- iso-wday 1))))
+    ;             (receive (yy mm dd) (priv:civil-from-days target-days)
+    ;               (set! month* mm)
+    ;               (set! day* dd))))
+    ;
+    ;         (make-date nanosecond*
+    ;                    second*
+    ;                    minute*
+    ;                    hour*
+    ;                    day*
+    ;                    month*
+    ;                    year*
+    ;                    zone-offset*)))))
     ))
diff --git a/goldfish/srfi/srfi-2.scm b/goldfish/srfi/srfi-2.scm
index 1fa42bfc0..ec096281f 100644
--- a/goldfish/srfi/srfi-2.scm
+++ b/goldfish/srfi/srfi-2.scm
@@ -3,9 +3,20 @@
   (export and-let*)
   (begin
 
-    (define-macro (and-let* vars . body)
-      `(let () (and ,@(map (lambda (v) `(define ,@v)) vars) (begin ,@body)))
-    ) ;define-macro
+    ;; and-let* using a flat let + and approach
+    ;; We accumulate all bindings and check them all with and
+    (define-syntax and-let*
+      (syntax-rules ()
+        ((_ () body ...)
+         (begin body ...))
+        ((_ ((var expr)) body ...)
+         (let ((var expr))
+           (and var (begin body ...))))
+        ((_ ((var expr) rest ...) body ...)
+         (let ((var expr))
+           (if var
+               (and-let* (rest ...) body ...)
+               #f)))))
 
   ) ;begin
 ) ;define-library
diff --git a/goldfish/srfi/srfi-217.scm b/goldfish/srfi/srfi-217.scm
index 3f179ffe0..8cd7c8e34 100644
--- a/goldfish/srfi/srfi-217.scm
+++ b/goldfish/srfi/srfi-217.scm
@@ -70,7 +70,7 @@
           (scheme case-lambda)
           (srfi srfi-1)
           (rename (liii bitwise)
-                  (ash arithmetic-shift)
+                  (ash bw:arithmetic-shift)
           ) ;rename
   ) ;import
 
@@ -130,6 +130,7 @@
 (define leaf-bitmap-size 32)
 
 (define suffix-mask (- leaf-bitmap-size 1))
+;; TODO: lognot first argument, #<undefined>
 (define prefix-mask (lognot suffix-mask))
 
 ;; In S7 Scheme, all integers are fixnums
@@ -188,7 +189,7 @@
 ) ;define
 
 (define (ibitmap k)
-  (arithmetic-shift 1 (isuffix k))
+  (bw:arithmetic-shift 1 (isuffix k))
 ) ;define
 
 (define (bitmap-delete bitmap key)
@@ -399,7 +400,7 @@
   (let loop ((i 0) (in 0) (out 0))
     (cond ((= i leaf-bitmap-size) (values in out))
           ((bit-set? i bitmap)
-           (let ((bit (arithmetic-shift 1 i)))
+           (let ((bit (bw:arithmetic-shift 1 i)))
              (if (pred (+ prefix i))
                  (loop (+ i 1) (logior in bit) out)
                  (loop (+ i 1) in (logior out bit))
@@ -446,7 +447,7 @@
   (let loop ((i 0) (res 0))
     (cond ((= i leaf-bitmap-size) res)
           ((and (bit-set? i bitmap) (pred (+ prefix i)))
-           (loop (+ i 1) (logior res (arithmetic-shift 1 i)))
+           (loop (+ i 1) (logior res (bw:arithmetic-shift 1 i)))
           ) ;
           (else (loop (+ i 1) res))
     ) ;cond
@@ -505,10 +506,9 @@
        ) ;cond
      ) ;lambda
     ) ;update
-   ) ;
+   ) ;letrec*
    (update trie))
-  ) ;letrec*
-) ;define
+  ) ;define
 
 (define (trie-delete-min trie)
   (letrec
@@ -1264,7 +1264,7 @@
           ((= kp prefix)
            (logand bitmap
                    (- (if inclusive
-                          (arithmetic-shift kb 1)
+                          (bw:arithmetic-shift kb 1)
                           kb)
                       1
                    ) ;-
@@ -1320,7 +1320,7 @@
            (logand bitmap
                    (- (if inclusive
                           kb
-                          (arithmetic-shift kb 1))
+                          (bw:arithmetic-shift kb 1))
                    ) ;-
            ) ;logand
           ) ;
@@ -1401,12 +1401,12 @@
       ((low-mask
          (- (if low-inclusive
                 lb
-                (arithmetic-shift lb 1))
+                (bw:arithmetic-shift lb 1))
          ) ;-
        ) ;low-mask
        (high-mask
          (- (if high-inclusive
-                (arithmetic-shift hb 1)
+                (bw:arithmetic-shift hb 1)
                 hb)
              1)
          ) ;-
@@ -2008,4 +2008,5 @@
   (raw-iset (subtrie> (iset-trie set) k #t))
 ) ;define
 
+) ;begin
 ) ;define-library
diff --git a/goldfish/srfi/srfi-224.scm b/goldfish/srfi/srfi-224.scm
index a68a2ee3e..c5d77f40f 100644
--- a/goldfish/srfi/srfi-224.scm
+++ b/goldfish/srfi/srfi-224.scm
@@ -72,7 +72,6 @@
   (import (scheme base)
           (scheme case-lambda)
           (srfi srfi-1)
-          (rename (liii bitwise) (ash arithmetic-shift))
   ) ;import
 
   (begin
diff --git a/goldfish/srfi/srfi-26.scm b/goldfish/srfi/srfi-26.scm
index 716d5ac2e..c87fd7cab 100644
--- a/goldfish/srfi/srfi-26.scm
+++ b/goldfish/srfi/srfi-26.scm
@@ -16,76 +16,52 @@
 
 (define-library (srfi srfi-26)
   (export cut cute)
-  (import (liii list)
-          (liii error)
-  ) ;import
   (begin
 
-    (define-macro (cut . paras)
-      (letrec*
-        ((slot? (lambda (x) (equal? '<> x)))
-         (more-slot? (lambda (x) (equal? '<...> x)))
-         (slots (filter slot? paras))
-         (more-slots (filter more-slot? paras))
-         (xs (map (lambda (x) (gensym)) slots))
-         (rest (gensym))
-         (parse
-           (lambda (xs paras)
-             (cond
-               ((null? paras) paras)
-               ((not (list? paras)) paras)
-               ((more-slot? (car paras)) `(,rest ,@(parse xs (cdr paras))))
-               ((slot? (car paras)) `(,(car xs) ,@(parse (cdr xs) (cdr paras))))
-               (else `(,(car paras) ,@(parse xs (cdr paras))))
-             ) ;cond
-           ) ;lambda
-         ) ;parse
-        ) ;
-        (cond
-          ((null? more-slots)
-           `(lambda ,xs ,(parse xs paras))
-          ) ;
-          (else
-            (when
-              (or (> (length more-slots) 1)
-                  (not (more-slot? (last paras)))
-              ) ;or
-              (error 'syntax-error "<...> must be the last parameter of cut")
-            ) ;when
-            (let ((parsed (parse xs paras)))
-              `(lambda (,@xs . ,rest) (apply ,@parsed))
-            ) ;let
-          ) ;else
-        ) ;cond
-      ) ;letrec*
-    ) ;define-macro
+    ;; Reference implementation of SRFI-26 using syntax-rules
+    ;; Based on the SRFI-26 reference implementation by Sebastian Egner
 
-    (define-macro (cute . paras)
-      (letrec*
-        ((slot? (lambda (x) (equal? '<> x)))
-         (more-slot? (lambda (x) (equal? '<...> x)))
-         (exprs (filter (lambda (x) (not (or (slot? x) (more-slot? x))))
-                        paras)
-         ) ;exprs
-         (xs (map (lambda (x) (gensym)) exprs))
-         (lets (map list xs exprs))
-         (parse
-           (lambda (xs paras)
-             (cond
-               ((null? paras) paras)
-               ((not (list? paras)) paras)
-               ((not (or (slot? (car paras)) (more-slot? (car paras))))
-                `(,(car xs) ,@(parse (cdr xs) (cdr paras)))
-               ) ;
-               (else `(,(car paras) ,@(parse xs (cdr paras))))
-             ) ;cond
-           ) ;lambda
-         ) ;parse
-        ) ;
-        `(let ,lets (cut ,@(parse xs paras)))
-      ) ;letrec*
-    ) ;define-macro
+    ;; Internal helper: cut with accumulated slots
+    (define-syntax %cut-internal
+      (syntax-rules (<> <...>)
+        ;; no more arguments - generate lambda
+        ((_ (slot-name ...) (proc arg ...))
+         (lambda (slot-name ...) (proc arg ...)))
+        ;; <...> at end - generate lambda with rest arg
+        ((_ (slot-name ...) (proc arg ...) <...>)
+         (lambda (slot-name ... . rest-slot) (apply proc arg ... rest-slot)))
+        ;; <> slot - add a new slot variable
+        ((_ (slot-name ...) (proc arg ...) <> . remaining)
+         (%cut-internal (slot-name ... x) (proc arg ... x) . remaining))
+        ;; non-slot argument
+        ((_ (slot-name ...) (proc arg ...) val . remaining)
+         (%cut-internal (slot-name ...) (proc arg ... val) . remaining))))
 
-  ) ;begin
-) ;define-library
+    (define-syntax cut
+      (syntax-rules ()
+        ((_ . args)
+         (%cut-internal () () . args))))
 
+    ;; Internal helper: cute with accumulated slots and evaluations
+    (define-syntax %cute-internal
+      (syntax-rules (<> <...>)
+        ;; no more arguments - generate let + lambda
+        ((_ (slot-name ...) (eval-bind ...) (proc arg ...))
+         (let (eval-bind ...) (lambda (slot-name ...) (proc arg ...))))
+        ;; <...> at end
+        ((_ (slot-name ...) (eval-bind ...) (proc arg ...) <...>)
+         (let (eval-bind ...) (lambda (slot-name ... . rest-slot) (apply proc arg ... rest-slot))))
+        ;; <> slot
+        ((_ (slot-name ...) (eval-bind ...) (proc arg ...) <> . remaining)
+         (%cute-internal (slot-name ... x) (eval-bind ...) (proc arg ... x) . remaining))
+        ;; non-slot - evaluate and bind
+        ((_ (slot-name ...) (eval-bind ...) (proc arg ...) val . remaining)
+         (%cute-internal (slot-name ...) (eval-bind ... (t val)) (proc arg ... t) . remaining))))
+
+    (define-syntax cute
+      (syntax-rules ()
+        ((_ . args)
+         (%cute-internal () () () . args))))
+
+    ) ; end of begin
+  ) ; end of library
diff --git a/goldfish/srfi/srfi-39.scm b/goldfish/srfi/srfi-39.scm
index 469d802cf..7ff5ee46f 100644
--- a/goldfish/srfi/srfi-39.scm
+++ b/goldfish/srfi/srfi-39.scm
@@ -7,34 +7,36 @@
   (begin
 
     ;; parameters
-    ;;   s7 has no built-in parameter objects
+    ;;   Parameter objects are procedures that respond to messages:
+    ;;   (p)          - get current value
+    ;;   (p 'push v)  - push new value (save old one)
+    ;;   (p 'pop)     - pop to previous value
     (define* (make-parameter init converter)
       (let* ((convert (or converter (lambda (x) x)))
-             (old-values ()) ; see below -- this is part of the funclet
+             (old-values ())
              (value (convert init)))
-        (lambda () value)
-      ) ;let*
-    ) ;define*
+        (lambda args
+          (if (null? args)
+              value
+              (case (car args)
+                ((push)
+                 (set! old-values (cons value old-values))
+                 (set! value (convert (cadr args))))
+                ((pop)
+                 (set! value (car old-values))
+                 (set! old-values (cdr old-values)))
+                (else value))))))
 
-    (define-macro (parameterize vars . body)
-      `(dynamic-wind
-         (lambda ()
-           ,@(map
-               (lambda (var)
-                 `(with-let (funclet ,(car var))
-                    (set! old-values (cons value old-values))
-                    (set! value (convert ,(cadr var)))))
-               vars))
-         (lambda () 
-           ,@body)
-         (lambda ()
-           ,@(map
-               (lambda (var)
-                 `(with-let (funclet ,(car var))
-                    (set! value (car old-values))
-                    (set! old-values (cdr old-values))))
-               vars)))
-    ) ;define-macro
+    (define-syntax parameterize
+      (syntax-rules ()
+        ((_ () body ...)
+         (let () body ...))
+        ((_ ((param val) rest ...) body ...)
+         (let ((p param))
+           (dynamic-wind
+             (lambda () (p 'push val))
+             (lambda () (parameterize (rest ...) body ...))
+             (lambda () (p 'pop)))))))
 
   ) ;begin
 ) ;define-library
diff --git a/goldfish/srfi/srfi-78.scm b/goldfish/srfi/srfi-78.scm
index fd3ed6972..116281694 100644
--- a/goldfish/srfi/srfi-78.scm
+++ b/goldfish/srfi/srfi-78.scm
@@ -61,9 +61,6 @@
       ) ;set!
     ) ;define
 
-
-    (check-set-mode! 'report)
-
     (define check:correct 0)
     (define check:failed '())
 
@@ -218,9 +215,8 @@
       ) ;let
     ) ;define*
 
-    (define-macro (check expr => expected)
-      `(check:proc ',expr (lambda () ,expr) ,expected)
-    ) ;define-macro
+    (define-syntax-rule (check expr => expected)
+      (check:proc 'expr (lambda () expr) expected))
 
     (define (check-report)
       (if (>= check:mode 1)
@@ -236,6 +232,8 @@
       ) ;if
     ) ;define
 
+
+    (check-set-mode! 'report)
   ) ;begin
 ) ;define-library
 
diff --git a/goldfish/srfi/srfi-8.scm b/goldfish/srfi/srfi-8.scm
index 13299ff0f..743185c33 100644
--- a/goldfish/srfi/srfi-8.scm
+++ b/goldfish/srfi/srfi-8.scm
@@ -18,11 +18,12 @@
   (export receive)              
   (begin
 
-    (define-macro (receive formals expression . body)
-      `(call-with-values
-        (lambda () (values ,expression))
-        (lambda ,formals ,@body))
-    ) ;define-macro
+    (define-syntax receive
+      (syntax-rules ()
+        ((_ formals expression body ...)
+         (call-with-values
+           (lambda () (values expression))
+           (lambda formals body ...)))))
 
   ) ;begin
 ) ;define-library
diff --git a/goldfish/x/alias-list-copy.scm b/goldfish/x/alias-list-copy.scm
new file mode 100644
index 000000000..5270d5eef
--- /dev/null
+++ b/goldfish/x/alias-list-copy.scm
@@ -0,0 +1,2 @@
+(define-library (x alias-list-copy)
+  (export (rename copy list-copy)))
diff --git a/goldfish/x/base.scm b/goldfish/x/base.scm
new file mode 100644
index 000000000..438f3dd86
--- /dev/null
+++ b/goldfish/x/base.scm
@@ -0,0 +1,3 @@
+(define-library (x base)
+  (export list-copy)
+  (import (x alias-list-copy)))
diff --git a/goldfish/x/srfi-1.scm b/goldfish/x/srfi-1.scm
new file mode 100644
index 000000000..a21101890
--- /dev/null
+++ b/goldfish/x/srfi-1.scm
@@ -0,0 +1,3 @@
+(define-library (x srfi-1)
+  (export list-copy)
+  (import (x alias-list-copy)))
diff --git a/goldfish/x/srfi-13.scm b/goldfish/x/srfi-13.scm
new file mode 100644
index 000000000..137b61f80
--- /dev/null
+++ b/goldfish/x/srfi-13.scm
@@ -0,0 +1,3 @@
+(define-library (x srfi-13)
+  (export list-copy)
+  (import (x base) (x srfi-1)))
diff --git a/psyntax-todo.md b/psyntax-todo.md
new file mode 100644
index 000000000..520341bae
--- /dev/null
+++ b/psyntax-todo.md
@@ -0,0 +1,88 @@
+# Psyntax TODO
+
+### SRFI checklist
+
+- [x] sicp.scm
+- [x] srfi-125.scm
+- [x] srfi-133.scm
+- [x] srfi-158.scm
+- [x] srfi-175.scm
+- [x] srfi-1.scm
+- [x] srfi-216.scm
+- [x] srfi-267.scm
+- [x] srfi-2.scm
+- [x] srfi-8.scm
+- [x] srfi-113.scm
+- [x] srfi-128.scm
+- [x] srfi-13.scm
+- [ ] srfi-165.scm
+- [x] srfi-196.scm
+- [x] srfi-209.scm
+- [ ] srfi-217.scm
+- [x] srfi-26.scm
+- [x] srfi-39.scm
+- [x] srfi-9.scm
+- [x] srfi-117.scm
+- [x] srfi-132.scm
+- [x] srfi-151.scm
+- [x] srfi-16.scm
+- [x] srfi-19.scm
+- [x] srfi-214.scm
+- [ ] srfi-224.scm
+- [ ] srfi-27.scm
+- [x] srfi-78.scm
+
+
+### Liii checklist
+
+- [x] alist.scm
+- [x] base.scm
+- [x] cut.scm
+- [ ] fxmapping.scm
+- [ ] json.scm
+- [ ] packrat.scm
+- [ ] raw-string.scm
+- [x] sys.scm
+- [x] unicode.scm
+- [ ] uri-predicate.scm
+- [ ] vector.scm
+- [x] argparse.scm
+- [x] bitwise.scm
+- [x] either.scm
+- [x] hashlib.scm
+- [x] list.scm
+- [ ] path.scm
+- [ ] set.scm
+- [x] timeit.scm
+- [ ] uri-compare.scm
+- [ ] uri-record.scm
+- [x] ascii.scm
+- [ ] check.scm
+- [x] enum.scm
+- [x] hash-table.scm
+- [ ] njson.scm
+- [x] queue.scm
+- [x] sort.scm
+- [x] time.scm
+- [ ] uri-convert.scm
+- [ ] uri.scm
+- [ ] bag.scm
+- [x] chez.scm
+- [x] error.scm
+- [ ] http.scm
+- [x] option.scm
+- [ ] random.scm
+- [ ] stack.scm
+- [ ] tree.scm
+- [ ] uri-make.scm
+- [ ] uri-transform.scm
+- [ ] base64.scm
+- [x] comparator.scm
+- [x] flexvector.scm
+- [ ] iset.scm
+- [x] os.scm
+- [x] range.scm
+- [x] string.scm
+- [x] trie.scm
+- [ ] uri-parse.scm
+- [x] uuid.scm
diff --git a/src/goldfish.hpp b/src/goldfish.hpp
index ef9ee7228..b2e61e1e1 100644
--- a/src/goldfish.hpp
+++ b/src/goldfish.hpp
@@ -73,8 +73,10 @@
 #define GOLDFISH_VERSION "17.11.50"
 
 #define GOLDFISH_PATH_MAXN TB_PATH_MAXN
+#define GOLDFISH_PATH_MAX 4096
 
 static std::vector<std::string> command_args= std::vector<std::string> ();
+static s7_pointer global_expander = NULL;
 
 // Declare environ for non-Windows platforms (needed for f_getenvs)
 #if !defined(TB_CONFIG_OS_WINDOWS)
@@ -2116,6 +2118,239 @@ f_delete_file (s7_scheme* sc, s7_pointer args) {
   return s7_make_boolean (sc, tb_file_remove (path_c));
 }
 
+static s7_pointer goldfish_sanitize_datum(s7_scheme *sc, s7_pointer obj) {
+    if (s7_is_pair(obj)) {
+        return s7_cons(sc,
+            goldfish_sanitize_datum(sc, s7_car(obj)),
+            goldfish_sanitize_datum(sc, s7_cdr(obj)));
+    }
+
+    if (!s7_is_symbol(obj) && !s7_is_number(obj) && !s7_is_string(obj) && !s7_is_boolean(obj)) {
+        char *str = s7_object_to_c_string(sc, obj);
+        s7_pointer result = obj;
+
+        if (strstr(str, "#_list-values") || strcmp(str, "list-values") == 0) {
+            result = s7_make_symbol(sc, "list-values");
+        } else if (strstr(str, "#_apply-values") || strcmp(str, "apply-values") == 0) {
+            result = s7_make_symbol(sc, "apply-values");
+        } else if (strstr(str, "#_quote") || strcmp(str, "quote") == 0) {
+            result = s7_make_symbol(sc, "quote");
+        }
+
+        free(str);
+        return result;
+    }
+
+    return obj;
+}
+
+static s7_pointer
+goldfish_read(s7_scheme *sc, s7_pointer port) {
+  s7_pointer raw_obj = s7_read(sc, port);
+  if (raw_obj == s7_eof_object(sc)) return raw_obj;
+  return goldfish_sanitize_datum(sc, raw_obj);
+}
+
+static s7_pointer
+f_goldfish_read(s7_scheme *sc, s7_pointer args) {
+  s7_pointer port;
+
+  /* 0 参数：使用 (current-input-port)；1 参数：使用提供的端口 */
+  if (s7_is_null(sc, args)) {
+    port = s7_current_input_port(sc);
+  } else {
+    port = s7_car(args);
+    /* 检查参数过多 */
+    if (!s7_is_null(sc, s7_cdr(args))) {
+      return s7_error(sc, s7_make_symbol(sc, "wrong-number-of-args"),
+                      s7_list(sc, 2, s7_make_string(sc, "goldfish-read takes at most 1 argument"), args));
+    }
+  }
+
+  if (!s7_is_input_port(sc, port)) {
+    return s7_wrong_type_arg_error(sc, "goldfish-read", 1, port, "an input port");
+  }
+
+  return goldfish_read(sc, port);
+}
+
+inline s7_pointer
+goldfish_eval(s7_scheme *sc, s7_pointer expr, s7_pointer env, const char* file) {
+  if (global_expander != NULL) {
+    /* (expander expr) */
+    auto expanded = s7_call_with_location(
+      sc,
+      global_expander,
+      s7_cons(sc, expr, s7_nil(sc)),
+      "sc-expand",
+      file,
+      0 // TODO(jinser): line information
+    );
+    expr = expanded;
+  }
+
+  return s7_eval(sc, expr, env);
+}
+
+inline s7_pointer
+goldfish_eval_c_string(s7_scheme *sc, const char *str, std::optional<s7_pointer> env = std::nullopt) {
+  auto port = s7_open_input_string(sc, str);
+  auto expr = goldfish_read(sc, port);
+  s7_close_input_port(sc, port);
+  return goldfish_eval(sc, expr, env.value_or(s7_rootlet(sc)), "<eval>");
+}
+
+inline s7_pointer
+goldfish_load(s7_scheme *sc, const char *filename, std::optional<s7_pointer> env = std::nullopt) {
+  s7_pointer port = NULL;
+  char full_path[GOLDFISH_PATH_MAX];
+
+  /* 1. 尝试直接路径（绝对路径或相对当前工作目录） */
+  if (tb_file_access (filename, TB_FILE_MODE_RO)) {
+    port = s7_open_input_file(sc, filename, "r");
+  }
+
+  /* 2. 失败则在 *load-path* 中搜索 */
+  if (!port) {
+    s7_pointer load_path = s7_load_path(sc);  /* 或 s7_name_to_value(sc, "*load-path*") */
+    size_t name_len = strlen(filename);
+
+    if (s7_is_list(sc, load_path)) {
+      for (s7_pointer p = load_path; s7_is_pair(p) && !port; p = s7_cdr(p)) {
+        s7_pointer dir = s7_car(p);
+        if (!s7_is_string(dir)) continue;
+
+        const char *dir_str = s7_string(dir);
+        size_t dir_len = strlen(dir_str);
+
+        /* 长度边界检查 */
+        if (dir_len + name_len + 2 > GOLDFISH_PATH_MAX) continue;
+
+        /* 拼接路径（处理末尾斜杠） */
+        if (dir_len > 0 && dir_str[dir_len - 1] == '/') {
+          snprintf(full_path, sizeof(full_path), "%s%s", dir_str, filename);
+        } else {
+          snprintf(full_path, sizeof(full_path), "%s/%s", dir_str, filename);
+        }
+
+        if (tb_file_access(full_path, TB_FILE_MODE_RO)) {
+          port = s7_open_input_file(sc, full_path, "r");
+        }
+      }
+    }
+  }
+
+  if (!port) {
+    return s7_error(sc, s7_make_symbol(sc, "cannot-open-file"),
+                    s7_list(sc, 2, s7_make_string(sc, "cannot open ~S"), 
+                            s7_make_string(sc, filename)));
+  }
+
+  // 1. 读取所有表达式到列表
+  s7_pointer forms = s7_nil(sc);
+  int count = 0;
+  auto gc_loc = s7_gc_protect(sc, port);
+  while (true) {
+    s7_pointer expr = goldfish_read(sc, port);
+    if (expr == s7_eof_object(sc)) break;
+
+    forms = s7_cons(sc, expr, forms);
+    count++;
+    if (count > 10000) {  // 防御：防止内存耗尽
+      s7_close_input_port(sc, port);
+      return s7_error(sc, s7_make_symbol(sc, "file-too-large"), 
+                     s7_make_string(sc, "too many expressions"));
+    }
+  }
+  s7_close_input_port(sc, port);
+  s7_gc_unprotect_at(sc, gc_loc);
+
+  if (s7_is_null(sc, forms)) return s7_unspecified(sc);  // 空文件
+
+  forms = s7_reverse(sc, forms);  // 恢复顺序
+
+  // 2. 组成 (begin expr1 expr2 ...)
+  s7_pointer wrapped = s7_cons(sc, s7_make_symbol(sc, "begin"), forms);
+
+  // 3. 一次性展开并求值（利用你已有的 goldfish_eval，它会调用 sc-expand）
+  return goldfish_eval(sc, wrapped, env.value_or(s7_rootlet(sc)), s7_port_filename(sc, port));
+}
+
+
+inline s7_pointer
+f_goldfish_eval(s7_scheme *sc, s7_pointer args) {
+  if (s7_is_null(sc, args)) {
+    return s7_error(sc, s7_make_symbol(sc, "wrong-number-of-args"),
+                    s7_list(sc, 2, s7_make_string(sc, "g_goldfish-eval requires at least 1 argument"), args));
+  }
+
+  s7_pointer expr = s7_car(args);
+  s7_pointer env = s7_curlet(sc);
+
+  if (!s7_is_null(sc, s7_cdr(args))) {
+    env = s7_cadr(args);
+    if (!s7_is_let(env)) {
+      return s7_error(sc, s7_make_symbol(sc, "wrong-type-arg"),
+                      s7_list(sc, 2, s7_make_string(sc, "environment must be a let"), env));
+    }
+  }
+
+  return goldfish_eval(sc, expr, env, "eval");
+}
+
+inline s7_pointer
+f_goldfish_eval_string(s7_scheme *sc, s7_pointer args) {
+  if (s7_is_null(sc, args)) {
+    return s7_error(sc, s7_make_symbol(sc, "wrong-number-of-args"),
+                   s7_list(sc, 2, s7_make_string(sc, "g_goldfish-eval-string requires at least 1 argument"), args));
+  }
+  
+  s7_pointer str = s7_car(args);
+  if (!s7_is_string(str)) {
+    return s7_error(sc, s7_make_symbol(sc, "wrong-type-arg"),
+                   s7_list(sc, 2, s7_make_string(sc, "argument must be a string"), str));
+  }
+  auto c_str = s7_string(str);
+
+  s7_pointer env = s7_curlet(sc);
+  if (!s7_is_null(sc, s7_cdr(args))) {
+    env = s7_cadr(args);
+    if (!s7_is_let(env)) {
+      return s7_error(sc, s7_make_symbol(sc, "wrong-type-arg"),
+                     s7_list(sc, 2, s7_make_string(sc, "environment must be a let"), env));
+    }
+  }
+
+  return goldfish_eval_c_string(sc, c_str, env);
+}
+
+inline s7_pointer
+f_goldfish_load(s7_scheme *sc, s7_pointer args) {
+  if (s7_is_null(sc, args)) {
+    return s7_error(sc, s7_make_symbol(sc, "wrong-number-of-args"),
+                    s7_list(sc, 2, s7_make_string(sc, "g_goldfish-load requires at least 1 argument"), args));
+  }
+
+  s7_pointer filename_arg = s7_car(args);
+  if (!s7_is_string(filename_arg)) {
+    return s7_error(sc, s7_make_symbol(sc, "wrong-type-arg"),
+                    s7_list(sc, 2, s7_make_string(sc, "filename must be a string"), filename_arg));
+  }
+
+  const char *filename = s7_string(filename_arg);
+  s7_pointer env = s7_rootlet(sc);
+
+  if (!s7_is_null(sc, s7_cdr(args))) {
+    env = s7_cadr(args);
+    if (!s7_is_let(env)) {
+      return s7_error(sc, s7_make_symbol(sc, "wrong-type-arg"),
+                      s7_list(sc, 2, s7_make_string(sc, "environment must be a let"), env));
+    }
+  }
+
+  return goldfish_load(sc, filename, env);
+}
+
 inline void
 glue_goldfish (s7_scheme* sc) {
   s7_pointer cur_env= s7_curlet (sc);
@@ -2130,6 +2365,14 @@ glue_goldfish (s7_scheme* sc) {
     "export function-name in the current *load-path*";
   const char* s_gfproject_load_config = "g_gfproject-load-config";
   const char* d_gfproject_load_config = "(g_gfproject-load-config) => string, returns merged gfproject.json";
+  const char* s_goldfish_read= "g_goldfish-read";
+  const char* d_goldfish_read= "(g_goldfish-read (port (current-input-port))) => any";
+  const char* s_goldfish_eval= "g_goldfish-eval";
+  const char* d_goldfish_eval= "(g_goldfish-eval expr (let (curlet))) => any value with sc-expand support";
+  const char* s_goldfish_eval_string= "g_goldfish-eval-string";
+  const char* d_goldfish_eval_string= "(g_goldfish-eval-string string (let (curlet))) => any";
+  const char* s_goldfish_load= "g_goldfish-load";
+  const char* d_goldfish_load= "(g_goldfish-load filename (let (rootlet))) => any, searches *load-path*";
 
   s7_define (sc, cur_env, s7_make_symbol (sc, s_version),
              s7_make_typed_function (sc, s_version, f_version, 0, 0, false, d_version, NULL));
@@ -2143,6 +2386,41 @@ glue_goldfish (s7_scheme* sc) {
   s7_define (sc, cur_env, s7_make_symbol (sc, s_gfproject_load_config),
              s7_make_typed_function (sc, s_gfproject_load_config, f_gfproject_load_config, 0, 0, false,
                                      d_gfproject_load_config, NULL));
+
+  s7_define (sc, cur_env, s7_make_symbol (sc, s_goldfish_read),
+             s7_make_typed_function (sc, s_goldfish_read, f_goldfish_read, 0, 1, false, d_goldfish_read, NULL));
+
+  s7_define (sc, cur_env, s7_make_symbol (sc, s_goldfish_eval),
+             s7_make_typed_function (sc, s_goldfish_eval, f_goldfish_eval, 1, 1, false, d_goldfish_eval, NULL));
+
+  s7_define (sc, cur_env, s7_make_symbol (sc, s_goldfish_eval_string),
+             s7_make_typed_function (sc, s_goldfish_eval_string, f_goldfish_eval_string, 1, 1, false, d_goldfish_eval_string, NULL));
+
+  s7_define (sc, cur_env, s7_make_symbol (sc, s_goldfish_load),
+             s7_make_typed_function (sc, s_goldfish_load, f_goldfish_load, 1, 1, false, d_goldfish_load, NULL));
+}
+
+/* (set-expander! proc)  proc 为 #f 时注销 */
+static s7_pointer
+f_set_expander(s7_scheme *sc, s7_pointer args) {
+  global_expander = s7_car(args);
+  if (s7_is_boolean(global_expander) && !s7_boolean(sc, global_expander))
+    global_expander = NULL;
+  return global_expander;
+}
+
+/* (current-expander) 返回当前注册的 expander 或 #f */
+static s7_pointer
+f_current_expander(s7_scheme *sc, s7_pointer args) {
+  return (global_expander != NULL) ? global_expander : s7_f(sc);
+}
+
+inline void
+glue_expander (s7_scheme* sc) {
+  s7_define_function(sc, "set-expander!", f_set_expander, 1, 0, false,
+                     "(set-expander! proc) register global expander");
+  s7_define_function(sc, "current-expander", f_current_expander, 0, 0, false,
+                     "(current-expander) get current global expander");
 }
 
 // old `f_current_second` TODO: use std::chrono::tai_clock::now() when using C++ 20
@@ -2161,6 +2439,7 @@ f_get_time_of_day (s7_scheme* sc, s7_pointer args) {
   return s7_values(sc, vs);
 }
 
+
 static s7_pointer
 f_monotonic_nanosecond (s7_scheme* sc, s7_pointer args) {
   using namespace std::chrono;
@@ -3375,6 +3654,7 @@ glue_liii_list (s7_scheme* sc) {
 void
 glue_for_community_edition (s7_scheme* sc) {
   glue_goldfish (sc);
+  glue_expander (sc);
   glue_scheme_time (sc);
   glue_scheme_process_context (sc);
   glue_liii_sys (sc);
@@ -3464,8 +3744,12 @@ display_for_invalid_options (const std::vector<std::string>& invalid_opts) {
 }
 
 static void
-goldfish_eval_file (s7_scheme* sc, string path, bool quiet) {
-  s7_pointer result= s7_load (sc, path.c_str ());
+ic_goldfish_eval_file (s7_scheme* sc, string path, bool quiet) {
+  if (!tb_file_access (path.c_str (), TB_FILE_MODE_RO)) {
+    cerr << "Error: file does not exist: " << path << endl;
+    exit (1);
+  }
+  s7_pointer result= goldfish_load (sc, path.c_str ());
   if (!result) {
     cerr << "Failed to load " << path << endl;
     exit (-1);
@@ -3780,6 +4064,12 @@ goldfish_eval_code (s7_scheme* sc, string code) {
   cout << s7_object_to_c_string (sc, x) << endl;
 }
 
+static void
+ic_goldfish_eval_code (s7_scheme* sc, string code) {
+  s7_pointer x= goldfish_eval_c_string (sc, code.c_str ());
+  cout << s7_object_to_c_string (sc, x) << endl;
+}
+
 struct GoldfixCliOptions {
   bool   enabled= false;
   bool   dry_run= false;
@@ -4441,20 +4731,20 @@ init_goldfish_scheme (const char* gf_lib) {
 void
 customize_goldfish_by_mode (s7_scheme* sc, string mode, const char* boot_file_path) {
   if (mode != "s7") {
-    s7_load (sc, boot_file_path);
+    goldfish_load (sc, boot_file_path);
   }
 
   if (mode == "default" || mode == "liii") {
     s7_eval_c_string (sc, "(import (liii base) (liii error) (liii string))");
   }
   else if (mode == "scheme") {
-    s7_eval_c_string (sc, "(import (liii base) (liii error))");
+    // goldfish_eval_c_string (sc, "(import (liii base) (liii error))");
   }
   else if (mode == "sicp") {
-    s7_eval_c_string (sc, "(import (scheme base) (srfi sicp))");
+    // goldfish_eval_c_string (sc, "(import (scheme base) (srfi sicp))");
   }
   else if (mode == "r7rs") {
-    s7_eval_c_string (sc, "(import (scheme base))");
+    // goldfish_eval_c_string (sc, "(import (scheme base))");
   }
   else if (mode == "s7") {
   }
@@ -4543,7 +4833,7 @@ ic_goldfish_eval (s7_scheme* sc, const char* code) {
   s7_pointer old_out_port= s7_set_current_output_port (sc, out_port);
   if (old_err_port != s7_nil (sc)) out_gc_loc= s7_gc_protect (sc, old_out_port);
 
-  s7_pointer result= s7_eval_c_string (sc, code);
+  s7_pointer result= goldfish_eval_c_string (sc, code);
 
   const char* display_out= s7_get_output_string (sc, out_port);
   if (display_out && *display_out) {
@@ -5609,7 +5899,7 @@ repl_for_community_edition (s7_scheme* sc, int argc, char** argv) {
       exit (1);
     }
     // 加载文件
-    goldfish_eval_file (sc, file, true);
+    ic_goldfish_eval_file (sc, file, true);
     errmsg= s7_get_output_string (sc, s7_current_error_port (sc));
     if ((errmsg) && (*errmsg)) {
       goldfish_print_scheme_error_message (sc, errmsg);
@@ -5701,7 +5991,7 @@ repl_for_community_edition (s7_scheme* sc, int argc, char** argv) {
         std::cerr << "Error: File not found: " << target << std::endl;
         return 1;
       }
-      goldfish_eval_file (sc, target, true);
+      ic_goldfish_eval_file (sc, target, true);
     }
     else {
       // 按模块名处理，例如: liii.string -> (liii string)
@@ -5747,7 +6037,7 @@ repl_for_community_edition (s7_scheme* sc, int argc, char** argv) {
   // 检查是否是文件
   std::error_code ec;
   if (fs::exists (command, ec) && fs::is_regular_file (command, ec)) {
-    goldfish_eval_file (sc, command, true);
+    ic_goldfish_eval_file (sc, command, true);
     errmsg= s7_get_output_string (sc, s7_current_error_port (sc));
     goldfish_print_scheme_error_message (sc, errmsg);
     s7_close_output_port (sc, s7_current_error_port (sc));
diff --git a/x.scm b/x.scm
new file mode 100644
index 000000000..c92fcf4be
--- /dev/null
+++ b/x.scm
@@ -0,0 +1,27 @@
+; (define-library (x)
+;   (import (scheme base))
+;   (begin (display (square 10))))
+
+;; 模拟一个简化版的 expand-import-spec，仅包含 rename 分支
+
+;; 测试用例
+(define-syntax test-import
+  (lambda (stx)
+    (define (test-expand spec-stx ctx)
+      (define (transform spec)
+        (syntax-case spec (rename)
+          ((rename lib (old new) ...)
+           #'(display undefined))))
+      (transform spec-stx))
+    (syntax-case stx ()
+      ((_ spec)
+       (let ((ctx (syntax _)))
+         (with-syntax ((expanded (test-expand (syntax spec) ctx)))
+           #'(begin
+               (write 'expanded:)
+               (write (syntax->datum (syntax expanded)))
+               (newline)
+               expanded)))))))
+
+;; 调用测试
+(test-import (rename (scheme base)))