guile-commits
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Guile-commits] GNU Guile branch, stable-2.0, updated. v2.0.5-69-g9120f1


From: Mark H Weaver
Subject: [Guile-commits] GNU Guile branch, stable-2.0, updated. v2.0.5-69-g9120f13
Date: Fri, 02 Mar 2012 23:28:22 +0000

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GNU Guile".

http://git.savannah.gnu.org/cgit/guile.git/commit/?id=9120f130a8ccd237d31806f381a1a1a25f5d930a

The branch, stable-2.0 has been updated
       via  9120f130a8ccd237d31806f381a1a1a25f5d930a (commit)
      from  dab48cc567f931b275ad647db1e47135b63c6675 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit 9120f130a8ccd237d31806f381a1a1a25f5d930a
Author: Mark H Weaver <address@hidden>
Date:   Fri Mar 2 17:54:23 2012 -0500

    Fix typos in psyntax.scm
    
    * module/ice-9/psyntax.scm (gen-syntax-case): #'pad --> #'pat
      (define*): #'x --> #'id
    
    * module/ice-9/psyntax-pp.scm: Regenerate

-----------------------------------------------------------------------

Summary of changes:
 module/ice-9/psyntax-pp.scm |32761 ++++++++++++++++++++++---------------------
 module/ice-9/psyntax.scm    |    4 +-
 2 files changed, 16419 insertions(+), 16346 deletions(-)

diff --git a/module/ice-9/psyntax-pp.scm b/module/ice-9/psyntax-pp.scm
index dd6b6ca..d11a3f8 100644
--- a/module/ice-9/psyntax-pp.scm
+++ b/module/ice-9/psyntax-pp.scm
@@ -1,1270 +1,1548 @@
 (eval-when (compile) (set-current-module (resolve-module (quote (guile)))))
 (if #f #f)
 
-(let ((session-id-4256 (if #f #f))
-      (transformer-environment-4317 (if #f #f)))
+(let ((session-id-4222 (if #f #f))
+      (transformer-environment-4283 (if #f #f)))
   (letrec*
-    ((top-level-eval-hook-4254
-       (lambda (x-27424 mod-27425)
-         (primitive-eval x-27424)))
-     (get-global-definition-hook-4258
-       (lambda (symbol-15687 module-15688)
+    ((top-level-eval-hook-4220
+       (lambda (x-24656 mod-24657)
+         (primitive-eval x-24656)))
+     (get-global-definition-hook-4224
+       (lambda (symbol-14704 module-14705)
          (begin
-           (if (if (not module-15688) (current-module) #f)
+           (if (if (not module-14705) (current-module) #f)
              (warn "module system is booted, we should have a module"
-                   symbol-15687))
-           (let ((v-15689
+                   symbol-14704))
+           (let ((v-14706
                    (module-variable
-                     (if module-15688
-                       (resolve-module (cdr module-15688))
+                     (if module-14705
+                       (resolve-module (cdr module-14705))
                        (current-module))
-                     symbol-15687)))
-             (if v-15689
-               (if (variable-bound? v-15689)
-                 (let ((val-15691 (variable-ref v-15689)))
-                   (if (macro? val-15691)
-                     (if (macro-type val-15691)
-                       (cons (macro-type val-15691)
-                             (macro-binding val-15691))
+                     symbol-14704)))
+             (if v-14706
+               (if (variable-bound? v-14706)
+                 (let ((val-14708 (variable-ref v-14706)))
+                   (if (macro? val-14708)
+                     (if (macro-type val-14708)
+                       (cons (macro-type val-14708)
+                             (macro-binding val-14708))
                        #f)
                      #f))
                  #f)
                #f)))))
-     (maybe-name-value!-4260
-       (lambda (name-15968 val-15969)
-         (if (if (struct? val-15969)
-               (eq? (struct-vtable val-15969)
+     (maybe-name-value!-4226
+       (lambda (name-21545 val-21546)
+         (if (if (struct? val-21546)
+               (eq? (struct-vtable val-21546)
                     (vector-ref %expanded-vtables 13))
                #f)
-           (let ((meta-15976 (struct-ref val-15969 1)))
-             (if (not (assq 'name meta-15976))
-               (let ((v-15981
-                       (cons (cons 'name name-15968) meta-15976)))
-                 (struct-set! val-15969 1 v-15981)))))))
-     (build-application-4262
-       (lambda (source-15693 fun-exp-15694 arg-exps-15695)
+           (let ((meta-21553 (struct-ref val-21546 1)))
+             (if (not (assq 'name meta-21553))
+               (let ((v-21558
+                       (cons (cons 'name name-21545) meta-21553)))
+                 (struct-set! val-21546 1 v-21558)))))))
+     (build-application-4228
+       (lambda (source-14710 fun-exp-14711 arg-exps-14712)
          (make-struct/no-tail
            (vector-ref %expanded-vtables 11)
-           source-15693
-           fun-exp-15694
-           arg-exps-15695)))
-     (build-conditional-4263
-       (lambda (source-15701
-                test-exp-15702
-                then-exp-15703
-                else-exp-15704)
-         (make-struct/no-tail
-           (vector-ref %expanded-vtables 10)
-           source-15701
-           test-exp-15702
-           then-exp-15703
-           else-exp-15704)))
-     (build-dynlet-4264
-       (lambda (source-15711 fluids-15712 vals-15713 body-15714)
-         (make-struct/no-tail
-           (vector-ref %expanded-vtables 17)
-           source-15711
-           fluids-15712
-           vals-15713
-           body-15714)))
-     (build-lexical-reference-4265
-       (lambda (type-27426 source-27427 name-27428 var-27429)
-         (make-struct/no-tail
-           (vector-ref %expanded-vtables 3)
-           source-27427
-           name-27428
-           var-27429)))
-     (build-lexical-assignment-4266
-       (lambda (source-15721 name-15722 var-15723 exp-15724)
-         (begin
-           (if (if (struct? exp-15724)
-                 (eq? (struct-vtable exp-15724)
-                      (vector-ref %expanded-vtables 13))
-                 #f)
-             (let ((meta-15740 (struct-ref exp-15724 1)))
-               (if (not (assq 'name meta-15740))
-                 (let ((v-15747
-                         (cons (cons 'name name-15722) meta-15740)))
-                   (struct-set! exp-15724 1 v-15747)))))
-           (make-struct/no-tail
-             (vector-ref %expanded-vtables 4)
-             source-15721
-             name-15722
-             var-15723
-             exp-15724))))
-     (analyze-variable-4267
-       (lambda (mod-27435
-                var-27436
-                modref-cont-27437
-                bare-cont-27438)
-         (if (not mod-27435)
-           (bare-cont-27438 var-27436)
-           (let ((kind-27439 (car mod-27435))
-                 (mod-27440 (cdr mod-27435)))
-             (if (eqv? kind-27439 'public)
-               (modref-cont-27437 mod-27440 var-27436 #t)
-               (if (eqv? kind-27439 'private)
-                 (if (not (equal? mod-27440 (module-name (current-module))))
-                   (modref-cont-27437 mod-27440 var-27436 #f)
-                   (bare-cont-27438 var-27436))
-                 (if (eqv? kind-27439 'bare)
-                   (bare-cont-27438 var-27436)
-                   (if (eqv? kind-27439 'hygiene)
+           source-14710
+           fun-exp-14711
+           arg-exps-14712)))
+     (analyze-variable-4233
+       (lambda (mod-14718
+                var-14719
+                modref-cont-14720
+                bare-cont-14721)
+         (if (not mod-14718)
+           (bare-cont-14721 var-14719)
+           (let ((kind-14722 (car mod-14718))
+                 (mod-14723 (cdr mod-14718)))
+             (if (eqv? kind-14722 'public)
+               (modref-cont-14720 mod-14723 var-14719 #t)
+               (if (eqv? kind-14722 'private)
+                 (if (not (equal? mod-14723 (module-name (current-module))))
+                   (modref-cont-14720 mod-14723 var-14719 #f)
+                   (bare-cont-14721 var-14719))
+                 (if (eqv? kind-14722 'bare)
+                   (bare-cont-14721 var-14719)
+                   (if (eqv? kind-14722 'hygiene)
                      (if (if (not (equal?
-                                    mod-27440
+                                    mod-14723
                                     (module-name (current-module))))
                            (module-variable
-                             (resolve-module mod-27440)
-                             var-27436)
+                             (resolve-module mod-14723)
+                             var-14719)
                            #f)
-                       (modref-cont-27437 mod-27440 var-27436 #f)
-                       (bare-cont-27438 var-27436))
+                       (modref-cont-14720 mod-14723 var-14719 #f)
+                       (bare-cont-14721 var-14719))
                      (syntax-violation
                        #f
                        "bad module kind"
-                       var-27436
-                       mod-27440)))))))))
-     (build-global-reference-4268
-       (lambda (source-27467 var-27468 mod-27469)
-         (analyze-variable-4267
-           mod-27469
-           var-27468
-           (lambda (mod-27472 var-27473 public?-27474)
-             (make-struct/no-tail
-               (vector-ref %expanded-vtables 5)
-               source-27467
-               mod-27472
-               var-27473
-               public?-27474))
-           (lambda (var-27482)
-             (make-struct/no-tail
-               (vector-ref %expanded-vtables 7)
-               source-27467
-               var-27482)))))
-     (build-global-assignment-4269
-       (lambda (source-15756 var-15757 exp-15758 mod-15759)
-         (begin
-           (if (if (struct? exp-15758)
-                 (eq? (struct-vtable exp-15758)
-                      (vector-ref %expanded-vtables 13))
-                 #f)
-             (let ((meta-15775 (struct-ref exp-15758 1)))
-               (if (not (assq 'name meta-15775))
-                 (let ((v-15782
-                         (cons (cons 'name var-15757) meta-15775)))
-                   (struct-set! exp-15758 1 v-15782)))))
-           (analyze-variable-4267
-             mod-15759
-             var-15757
-             (lambda (mod-15787 var-15788 public?-15789)
-               (make-struct/no-tail
-                 (vector-ref %expanded-vtables 6)
-                 source-15756
-                 mod-15787
-                 var-15788
-                 public?-15789
-                 exp-15758))
-             (lambda (var-15797)
-               (make-struct/no-tail
-                 (vector-ref %expanded-vtables 8)
-                 source-15756
-                 var-15797
-                 exp-15758))))))
-     (build-global-definition-4270
-       (lambda (source-27488 var-27489 exp-27490)
-         (begin
-           (if (if (struct? exp-27490)
-                 (eq? (struct-vtable exp-27490)
-                      (vector-ref %expanded-vtables 13))
-                 #f)
-             (let ((meta-27506 (struct-ref exp-27490 1)))
-               (if (not (assq 'name meta-27506))
-                 (let ((v-27513
-                         (cons (cons 'name var-27489) meta-27506)))
-                   (struct-set! exp-27490 1 v-27513)))))
-           (make-struct/no-tail
-             (vector-ref %expanded-vtables 9)
-             source-27488
-             var-27489
-             exp-27490))))
-     (build-simple-lambda-4271
-       (lambda (src-15803
-                req-15804
-                rest-15805
-                vars-15806
-                meta-15807
-                exp-15808)
-         (let ((body-15814
+                       var-14719
+                       mod-14723)))))))))
+     (build-simple-lambda-4237
+       (lambda (src-14750
+                req-14751
+                rest-14752
+                vars-14753
+                meta-14754
+                exp-14755)
+         (let ((body-14761
                  (make-struct/no-tail
                    (vector-ref %expanded-vtables 14)
-                   src-15803
-                   req-15804
+                   src-14750
+                   req-14751
                    #f
-                   rest-15805
+                   rest-14752
                    #f
                    '()
-                   vars-15806
-                   exp-15808
+                   vars-14753
+                   exp-14755
                    #f)))
            (make-struct/no-tail
              (vector-ref %expanded-vtables 13)
-             src-15803
-             meta-15807
-             body-15814))))
-     (build-sequence-4276
-       (lambda (src-27521 exps-27522)
-         (if (null? (cdr exps-27522))
-           (car exps-27522)
+             src-14750
+             meta-14754
+             body-14761))))
+     (build-sequence-4242
+       (lambda (src-24658 exps-24659)
+         (if (null? (cdr exps-24659))
+           (car exps-24659)
            (make-struct/no-tail
              (vector-ref %expanded-vtables 12)
-             src-27521
-             exps-27522))))
-     (build-let-4277
-       (lambda (src-15826
-                ids-15827
-                vars-15828
-                val-exps-15829
-                body-exp-15830)
+             src-24658
+             exps-24659))))
+     (build-let-4243
+       (lambda (src-14773
+                ids-14774
+                vars-14775
+                val-exps-14776
+                body-exp-14777)
          (begin
            (for-each
-             maybe-name-value!-4260
-             ids-15827
-             val-exps-15829)
-           (if (null? vars-15828)
-             body-exp-15830
+             maybe-name-value!-4226
+             ids-14774
+             val-exps-14776)
+           (if (null? vars-14775)
+             body-exp-14777
              (make-struct/no-tail
                (vector-ref %expanded-vtables 15)
-               src-15826
-               ids-15827
-               vars-15828
-               val-exps-15829
-               body-exp-15830)))))
-     (build-named-let-4278
-       (lambda (src-15854
-                ids-15855
-                vars-15856
-                val-exps-15857
-                body-exp-15858)
-         (let ((f-15859 (car vars-15856))
-               (f-name-15860 (car ids-15855))
-               (vars-15861 (cdr vars-15856))
-               (ids-15862 (cdr ids-15855)))
-           (let ((proc-15863
-                   (let ((body-15883
+               src-14773
+               ids-14774
+               vars-14775
+               val-exps-14776
+               body-exp-14777)))))
+     (build-named-let-4244
+       (lambda (src-14801
+                ids-14802
+                vars-14803
+                val-exps-14804
+                body-exp-14805)
+         (let ((f-14806 (car vars-14803))
+               (f-name-14807 (car ids-14802))
+               (vars-14808 (cdr vars-14803))
+               (ids-14809 (cdr ids-14802)))
+           (let ((proc-14810
+                   (let ((body-14830
                            (make-struct/no-tail
                              (vector-ref %expanded-vtables 14)
-                             src-15854
-                             ids-15862
+                             src-14801
+                             ids-14809
                              #f
                              #f
                              #f
                              '()
-                             vars-15861
-                             body-exp-15858
+                             vars-14808
+                             body-exp-14805
                              #f)))
                      (make-struct/no-tail
                        (vector-ref %expanded-vtables 13)
-                       src-15854
+                       src-14801
                        '()
-                       body-15883))))
+                       body-14830))))
              (begin
-               (if (if (struct? proc-15863)
-                     (eq? (struct-vtable proc-15863)
+               (if (if (struct? proc-14810)
+                     (eq? (struct-vtable proc-14810)
                           (vector-ref %expanded-vtables 13))
                      #f)
-                 (let ((meta-15907 (struct-ref proc-15863 1)))
-                   (if (not (assq 'name meta-15907))
-                     (let ((v-15914
-                             (cons (cons 'name f-name-15860) meta-15907)))
-                       (struct-set! proc-15863 1 v-15914)))))
+                 (let ((meta-14854 (struct-ref proc-14810 1)))
+                   (if (not (assq 'name meta-14854))
+                     (let ((v-14861
+                             (cons (cons 'name f-name-14807) meta-14854)))
+                       (struct-set! proc-14810 1 v-14861)))))
                (for-each
-                 maybe-name-value!-4260
-                 ids-15862
-                 val-exps-15857)
-               (let ((names-15938 (list f-name-15860))
-                     (gensyms-15939 (list f-15859))
-                     (vals-15940 (list proc-15863))
-                     (body-15941
-                       (let ((fun-exp-15945
+                 maybe-name-value!-4226
+                 ids-14809
+                 val-exps-14804)
+               (let ((names-14885 (list f-name-14807))
+                     (gensyms-14886 (list f-14806))
+                     (vals-14887 (list proc-14810))
+                     (body-14888
+                       (let ((fun-exp-14892
                                (make-struct/no-tail
                                  (vector-ref %expanded-vtables 3)
-                                 src-15854
-                                 f-name-15860
-                                 f-15859)))
+                                 src-14801
+                                 f-name-14807
+                                 f-14806)))
                          (make-struct/no-tail
                            (vector-ref %expanded-vtables 11)
-                           src-15854
-                           fun-exp-15945
-                           val-exps-15857))))
+                           src-14801
+                           fun-exp-14892
+                           val-exps-14804))))
                  (make-struct/no-tail
                    (vector-ref %expanded-vtables 16)
-                   src-15854
+                   src-14801
                    #f
-                   names-15938
-                   gensyms-15939
-                   vals-15940
-                   body-15941)))))))
-     (build-letrec-4279
-       (lambda (src-15961
-                in-order?-15962
-                ids-15963
-                vars-15964
-                val-exps-15965
-                body-exp-15966)
-         (if (null? vars-15964)
-           body-exp-15966
+                   names-14885
+                   gensyms-14886
+                   vals-14887
+                   body-14888)))))))
+     (build-letrec-4245
+       (lambda (src-14908
+                in-order?-14909
+                ids-14910
+                vars-14911
+                val-exps-14912
+                body-exp-14913)
+         (if (null? vars-14911)
+           body-exp-14913
            (begin
              (for-each
-               maybe-name-value!-4260
-               ids-15963
-               val-exps-15965)
+               maybe-name-value!-4226
+               ids-14910
+               val-exps-14912)
              (make-struct/no-tail
                (vector-ref %expanded-vtables 16)
-               src-15961
-               in-order?-15962
-               ids-15963
-               vars-15964
-               val-exps-15965
-               body-exp-15966)))))
-     (source-annotation-4288
-       (lambda (x-15992)
-         (if (if (vector? x-15992)
-               (if (= (vector-length x-15992) 4)
-                 (eq? (vector-ref x-15992 0) 'syntax-object)
-                 #f)
-               #f)
-           (source-annotation-4288 (vector-ref x-15992 1))
-           (let ((props-16007 (source-properties x-15992)))
-             (if (pair? props-16007) props-16007 #f)))))
-     (extend-env-4289
-       (lambda (labels-16009 bindings-16010 r-16011)
-         (if (null? labels-16009)
-           r-16011
-           (extend-env-4289
-             (cdr labels-16009)
-             (cdr bindings-16010)
-             (cons (cons (car labels-16009) (car bindings-16010))
-                   r-16011)))))
-     (extend-var-env-4290
-       (lambda (labels-16012 vars-16013 r-16014)
-         (if (null? labels-16012)
-           r-16014
-           (extend-var-env-4290
-             (cdr labels-16012)
-             (cdr vars-16013)
-             (cons (cons (car labels-16012)
-                         (cons 'lexical (car vars-16013)))
-                   r-16014)))))
-     (macros-only-env-4291
-       (lambda (r-16015)
-         (if (null? r-16015)
+               src-14908
+               in-order?-14909
+               ids-14910
+               vars-14911
+               val-exps-14912
+               body-exp-14913)))))
+     (extend-env-4255
+       (lambda (labels-14939 bindings-14940 r-14941)
+         (if (null? labels-14939)
+           r-14941
+           (extend-env-4255
+             (cdr labels-14939)
+             (cdr bindings-14940)
+             (cons (cons (car labels-14939) (car bindings-14940))
+                   r-14941)))))
+     (extend-var-env-4256
+       (lambda (labels-14942 vars-14943 r-14944)
+         (if (null? labels-14942)
+           r-14944
+           (extend-var-env-4256
+             (cdr labels-14942)
+             (cdr vars-14943)
+             (cons (cons (car labels-14942)
+                         (cons 'lexical (car vars-14943)))
+                   r-14944)))))
+     (macros-only-env-4257
+       (lambda (r-14945)
+         (if (null? r-14945)
            '()
-           (let ((a-16016 (car r-16015)))
-             (if (eq? (car (cdr a-16016)) 'macro)
-               (cons a-16016
-                     (macros-only-env-4291 (cdr r-16015)))
-               (macros-only-env-4291 (cdr r-16015)))))))
-     (global-extend-4293
-       (lambda (type-16018 sym-16019 val-16020)
+           (let ((a-14946 (car r-14945)))
+             (if (eq? (car (cdr a-14946)) 'macro)
+               (cons a-14946
+                     (macros-only-env-4257 (cdr r-14945)))
+               (macros-only-env-4257 (cdr r-14945)))))))
+     (global-extend-4259
+       (lambda (type-14948 sym-14949 val-14950)
          (module-define!
            (current-module)
-           sym-16019
+           sym-14949
            (make-syntax-transformer
-             sym-16019
-             type-16018
-             val-16020))))
-     (id?-4295
-       (lambda (x-9601)
-         (if (symbol? x-9601)
+             sym-14949
+             type-14948
+             val-14950))))
+     (id?-4261
+       (lambda (x-9380)
+         (if (symbol? x-9380)
            #t
-           (if (if (vector? x-9601)
-                 (if (= (vector-length x-9601) 4)
-                   (eq? (vector-ref x-9601 0) 'syntax-object)
+           (if (if (vector? x-9380)
+                 (if (= (vector-length x-9380) 4)
+                   (eq? (vector-ref x-9380 0) 'syntax-object)
                    #f)
                  #f)
-             (symbol? (vector-ref x-9601 1))
+             (symbol? (vector-ref x-9380 1))
              #f))))
-     (gen-labels-4298
-       (lambda (ls-16030)
-         (if (null? ls-16030)
+     (gen-labels-4264
+       (lambda (ls-14960)
+         (if (null? ls-14960)
            '()
            (cons (string-append
                    "l-"
-                   (session-id-4256)
+                   (session-id-4222)
                    (symbol->string (gensym "-")))
-                 (gen-labels-4298 (cdr ls-16030))))))
-     (make-binding-wrap-4309
-       (lambda (ids-16034 labels-16035 w-16036)
-         (if (null? ids-16034)
-           w-16036
-           (cons (car w-16036)
-                 (cons (let ((labelvec-16037 (list->vector labels-16035)))
-                         (let ((n-16038 (vector-length labelvec-16037)))
-                           (let ((symnamevec-16039 (make-vector n-16038))
-                                 (marksvec-16040 (make-vector n-16038)))
+                 (gen-labels-4264 (cdr ls-14960))))))
+     (make-binding-wrap-4275
+       (lambda (ids-14964 labels-14965 w-14966)
+         (if (null? ids-14964)
+           w-14966
+           (cons (car w-14966)
+                 (cons (let ((labelvec-14967 (list->vector labels-14965)))
+                         (let ((n-14968 (vector-length labelvec-14967)))
+                           (let ((symnamevec-14969 (make-vector n-14968))
+                                 (marksvec-14970 (make-vector n-14968)))
                              (begin
                                (letrec*
-                                 ((f-16041
-                                    (lambda (ids-16044 i-16045)
-                                      (if (not (null? ids-16044))
+                                 ((f-14971
+                                    (lambda (ids-14974 i-14975)
+                                      (if (not (null? ids-14974))
                                         (call-with-values
                                           (lambda ()
-                                            (let ((x-16048 (car ids-16044)))
-                                              (if (if (vector? x-16048)
+                                            (let ((x-14978 (car ids-14974)))
+                                              (if (if (vector? x-14978)
                                                     (if (= (vector-length
-                                                             x-16048)
+                                                             x-14978)
                                                            4)
                                                       (eq? (vector-ref
-                                                             x-16048
+                                                             x-14978
                                                              0)
                                                            'syntax-object)
                                                       #f)
                                                     #f)
                                                 (values
-                                                  (vector-ref x-16048 1)
-                                                  (let ((m1-16064
-                                                          (car w-16036))
-                                                        (m2-16065
+                                                  (vector-ref x-14978 1)
+                                                  (let ((m1-14994
+                                                          (car w-14966))
+                                                        (m2-14995
                                                           (car (vector-ref
-                                                                 x-16048
+                                                                 x-14978
                                                                  2))))
-                                                    (if (null? m2-16065)
-                                                      m1-16064
+                                                    (if (null? m2-14995)
+                                                      m1-14994
                                                       (append
-                                                        m1-16064
-                                                        m2-16065))))
+                                                        m1-14994
+                                                        m2-14995))))
                                                 (values
-                                                  x-16048
-                                                  (car w-16036)))))
-                                          (lambda (symname-16085 marks-16086)
+                                                  x-14978
+                                                  (car w-14966)))))
+                                          (lambda (symname-15015 marks-15016)
                                             (begin
                                               (vector-set!
-                                                symnamevec-16039
-                                                i-16045
-                                                symname-16085)
+                                                symnamevec-14969
+                                                i-14975
+                                                symname-15015)
                                               (vector-set!
-                                                marksvec-16040
-                                                i-16045
-                                                marks-16086)
-                                              (f-16041
-                                                (cdr ids-16044)
-                                                (#{1+}# i-16045)))))))))
-                                 (f-16041 ids-16034 0))
+                                                marksvec-14970
+                                                i-14975
+                                                marks-15016)
+                                              (f-14971
+                                                (cdr ids-14974)
+                                                (#{1+}# i-14975)))))))))
+                                 (f-14971 ids-14964 0))
                                (vector
                                  'ribcage
-                                 symnamevec-16039
-                                 marksvec-16040
-                                 labelvec-16037)))))
-                       (cdr w-16036))))))
-     (join-wraps-4311
-       (lambda (w1-16095 w2-16096)
-         (let ((m1-16097 (car w1-16095))
-               (s1-16098 (cdr w1-16095)))
-           (if (null? m1-16097)
-             (if (null? s1-16098)
-               w2-16096
-               (cons (car w2-16096)
-                     (let ((m2-16105 (cdr w2-16096)))
-                       (if (null? m2-16105)
-                         s1-16098
-                         (append s1-16098 m2-16105)))))
-             (cons (let ((m2-16114 (car w2-16096)))
-                     (if (null? m2-16114)
-                       m1-16097
-                       (append m1-16097 m2-16114)))
-                   (let ((m2-16123 (cdr w2-16096)))
-                     (if (null? m2-16123)
-                       s1-16098
-                       (append s1-16098 m2-16123))))))))
-     (same-marks?-4313
-       (lambda (x-16128 y-16129)
-         (if (eq? x-16128 y-16129)
-           (eq? x-16128 y-16129)
-           (if (not (null? x-16128))
-             (if (not (null? y-16129))
-               (if (eq? (car x-16128) (car y-16129))
-                 (same-marks?-4313 (cdr x-16128) (cdr y-16129))
+                                 symnamevec-14969
+                                 marksvec-14970
+                                 labelvec-14967)))))
+                       (cdr w-14966))))))
+     (join-wraps-4277
+       (lambda (w1-15025 w2-15026)
+         (let ((m1-15027 (car w1-15025))
+               (s1-15028 (cdr w1-15025)))
+           (if (null? m1-15027)
+             (if (null? s1-15028)
+               w2-15026
+               (cons (car w2-15026)
+                     (let ((m2-15035 (cdr w2-15026)))
+                       (if (null? m2-15035)
+                         s1-15028
+                         (append s1-15028 m2-15035)))))
+             (cons (let ((m2-15044 (car w2-15026)))
+                     (if (null? m2-15044)
+                       m1-15027
+                       (append m1-15027 m2-15044)))
+                   (let ((m2-15053 (cdr w2-15026)))
+                     (if (null? m2-15053)
+                       s1-15028
+                       (append s1-15028 m2-15053))))))))
+     (same-marks?-4279
+       (lambda (x-15058 y-15059)
+         (if (eq? x-15058 y-15059)
+           (eq? x-15058 y-15059)
+           (if (not (null? x-15058))
+             (if (not (null? y-15059))
+               (if (eq? (car x-15058) (car y-15059))
+                 (same-marks?-4279 (cdr x-15058) (cdr y-15059))
                  #f)
                #f)
              #f))))
-     (id-var-name-4314
-       (lambda (id-16137 w-16138)
+     (id-var-name-4280
+       (lambda (id-15067 w-15068)
          (letrec*
-           ((search-16139
-              (lambda (sym-16200 subst-16201 marks-16202)
-                (if (null? subst-16201)
-                  (values #f marks-16202)
-                  (let ((fst-16203 (car subst-16201)))
-                    (if (eq? fst-16203 'shift)
-                      (search-16139
-                        sym-16200
-                        (cdr subst-16201)
-                        (cdr marks-16202))
-                      (let ((symnames-16205 (vector-ref fst-16203 1)))
-                        (if (vector? symnames-16205)
-                          (let ((n-16217 (vector-length symnames-16205)))
+           ((search-15069
+              (lambda (sym-15130 subst-15131 marks-15132)
+                (if (null? subst-15131)
+                  (values #f marks-15132)
+                  (let ((fst-15133 (car subst-15131)))
+                    (if (eq? fst-15133 'shift)
+                      (search-15069
+                        sym-15130
+                        (cdr subst-15131)
+                        (cdr marks-15132))
+                      (let ((symnames-15135 (vector-ref fst-15133 1)))
+                        (if (vector? symnames-15135)
+                          (let ((n-15147 (vector-length symnames-15135)))
                             (letrec*
-                              ((f-16218
-                                 (lambda (i-16220)
-                                   (if (= i-16220 n-16217)
-                                     (search-16139
-                                       sym-16200
-                                       (cdr subst-16201)
-                                       marks-16202)
+                              ((f-15148
+                                 (lambda (i-15150)
+                                   (if (= i-15150 n-15147)
+                                     (search-15069
+                                       sym-15130
+                                       (cdr subst-15131)
+                                       marks-15132)
                                      (if (if (eq? (vector-ref
-                                                    symnames-16205
-                                                    i-16220)
-                                                  sym-16200)
-                                           (same-marks?-4313
-                                             marks-16202
+                                                    symnames-15135
+                                                    i-15150)
+                                                  sym-15130)
+                                           (same-marks?-4279
+                                             marks-15132
                                              (vector-ref
-                                               (vector-ref fst-16203 2)
-                                               i-16220))
+                                               (vector-ref fst-15133 2)
+                                               i-15150))
                                            #f)
                                        (values
                                          (vector-ref
-                                           (vector-ref fst-16203 3)
-                                           i-16220)
-                                         marks-16202)
-                                       (f-16218 (#{1+}# i-16220)))))))
-                              (f-16218 0)))
+                                           (vector-ref fst-15133 3)
+                                           i-15150)
+                                         marks-15132)
+                                       (f-15148 (#{1+}# i-15150)))))))
+                              (f-15148 0)))
                           (letrec*
-                            ((f-16253
-                               (lambda (symnames-16255 i-16256)
-                                 (if (null? symnames-16255)
-                                   (search-16139
-                                     sym-16200
-                                     (cdr subst-16201)
-                                     marks-16202)
-                                   (if (if (eq? (car symnames-16255) sym-16200)
-                                         (same-marks?-4313
-                                           marks-16202
+                            ((f-15183
+                               (lambda (symnames-15185 i-15186)
+                                 (if (null? symnames-15185)
+                                   (search-15069
+                                     sym-15130
+                                     (cdr subst-15131)
+                                     marks-15132)
+                                   (if (if (eq? (car symnames-15185) sym-15130)
+                                         (same-marks?-4279
+                                           marks-15132
                                            (list-ref
-                                             (vector-ref fst-16203 2)
-                                             i-16256))
+                                             (vector-ref fst-15133 2)
+                                             i-15186))
                                          #f)
                                      (values
                                        (list-ref
-                                         (vector-ref fst-16203 3)
-                                         i-16256)
-                                       marks-16202)
-                                     (f-16253
-                                       (cdr symnames-16255)
-                                       (#{1+}# i-16256)))))))
-                            (f-16253 symnames-16205 0))))))))))
-           (if (symbol? id-16137)
-             (let ((t-16142
-                     (search-16139
-                       id-16137
-                       (cdr w-16138)
-                       (car w-16138))))
-               (if t-16142 t-16142 id-16137))
-             (if (if (vector? id-16137)
-                   (if (= (vector-length id-16137) 4)
-                     (eq? (vector-ref id-16137 0) 'syntax-object)
+                                         (vector-ref fst-15133 3)
+                                         i-15186)
+                                       marks-15132)
+                                     (f-15183
+                                       (cdr symnames-15185)
+                                       (#{1+}# i-15186)))))))
+                            (f-15183 symnames-15135 0))))))))))
+           (if (symbol? id-15067)
+             (let ((t-15072
+                     (search-15069
+                       id-15067
+                       (cdr w-15068)
+                       (car w-15068))))
+               (if t-15072 t-15072 id-15067))
+             (if (if (vector? id-15067)
+                   (if (= (vector-length id-15067) 4)
+                     (eq? (vector-ref id-15067 0) 'syntax-object)
                      #f)
                    #f)
-               (let ((id-16157 (vector-ref id-16137 1))
-                     (w1-16158 (vector-ref id-16137 2)))
-                 (let ((marks-16159
-                         (let ((m1-16169 (car w-16138))
-                               (m2-16170 (car w1-16158)))
-                           (if (null? m2-16170)
-                             m1-16169
-                             (append m1-16169 m2-16170)))))
+               (let ((id-15087 (vector-ref id-15067 1))
+                     (w1-15088 (vector-ref id-15067 2)))
+                 (let ((marks-15089
+                         (let ((m1-15099 (car w-15068))
+                               (m2-15100 (car w1-15088)))
+                           (if (null? m2-15100)
+                             m1-15099
+                             (append m1-15099 m2-15100)))))
                    (call-with-values
                      (lambda ()
-                       (search-16139 id-16157 (cdr w-16138) marks-16159))
-                     (lambda (new-id-16186 marks-16187)
-                       (if new-id-16186
-                         new-id-16186
-                         (let ((t-16195
-                                 (search-16139
-                                   id-16157
-                                   (cdr w1-16158)
-                                   marks-16187)))
-                           (if t-16195 t-16195 id-16157)))))))
+                       (search-15069 id-15087 (cdr w-15068) marks-15089))
+                     (lambda (new-id-15116 marks-15117)
+                       (if new-id-15116
+                         new-id-15116
+                         (let ((t-15125
+                                 (search-15069
+                                   id-15087
+                                   (cdr w1-15088)
+                                   marks-15117)))
+                           (if t-15125 t-15125 id-15087)))))))
                (syntax-violation
                  'id-var-name
                  "invalid id"
-                 id-16137))))))
-     (locally-bound-identifiers-4315
-       (lambda (w-16278 mod-16279)
+                 id-15067))))))
+     (locally-bound-identifiers-4281
+       (lambda (w-15208 mod-15209)
          (letrec*
-           ((scan-16280
-              (lambda (subst-16285 results-16286)
-                (if (null? subst-16285)
-                  results-16286
-                  (let ((fst-16287 (car subst-16285)))
-                    (if (eq? fst-16287 'shift)
-                      (scan-16280 (cdr subst-16285) results-16286)
-                      (let ((symnames-16289 (vector-ref fst-16287 1))
-                            (marks-16290 (vector-ref fst-16287 2)))
-                        (if (vector? symnames-16289)
-                          (scan-vector-rib-16282
-                            subst-16285
-                            symnames-16289
-                            marks-16290
-                            results-16286)
-                          (scan-list-rib-16281
-                            subst-16285
-                            symnames-16289
-                            marks-16290
-                            results-16286))))))))
-            (scan-list-rib-16281
-              (lambda (subst-16388
-                       symnames-16389
-                       marks-16390
-                       results-16391)
+           ((scan-15210
+              (lambda (subst-15215 results-15216)
+                (if (null? subst-15215)
+                  results-15216
+                  (let ((fst-15217 (car subst-15215)))
+                    (if (eq? fst-15217 'shift)
+                      (scan-15210 (cdr subst-15215) results-15216)
+                      (let ((symnames-15219 (vector-ref fst-15217 1))
+                            (marks-15220 (vector-ref fst-15217 2)))
+                        (if (vector? symnames-15219)
+                          (scan-vector-rib-15212
+                            subst-15215
+                            symnames-15219
+                            marks-15220
+                            results-15216)
+                          (scan-list-rib-15211
+                            subst-15215
+                            symnames-15219
+                            marks-15220
+                            results-15216))))))))
+            (scan-list-rib-15211
+              (lambda (subst-15318
+                       symnames-15319
+                       marks-15320
+                       results-15321)
                 (letrec*
-                  ((f-16392
-                     (lambda (symnames-16492 marks-16493 results-16494)
-                       (if (null? symnames-16492)
-                         (scan-16280 (cdr subst-16388) results-16494)
-                         (f-16392
-                           (cdr symnames-16492)
-                           (cdr marks-16493)
-                           (cons (wrap-4324
-                                   (car symnames-16492)
-                                   (let ((w-16502
-                                           (cons (car marks-16493)
-                                                 subst-16388)))
-                                     (cons (cons #f (car w-16502))
-                                           (cons 'shift (cdr w-16502))))
-                                   mod-16279)
-                                 results-16494))))))
-                  (f-16392
-                    symnames-16389
-                    marks-16390
-                    results-16391))))
-            (scan-vector-rib-16282
-              (lambda (subst-16503
-                       symnames-16504
-                       marks-16505
-                       results-16506)
-                (let ((n-16507 (vector-length symnames-16504)))
+                  ((f-15322
+                     (lambda (symnames-15422 marks-15423 results-15424)
+                       (if (null? symnames-15422)
+                         (scan-15210 (cdr subst-15318) results-15424)
+                         (f-15322
+                           (cdr symnames-15422)
+                           (cdr marks-15423)
+                           (cons (wrap-4290
+                                   (car symnames-15422)
+                                   (let ((w-15432
+                                           (cons (car marks-15423)
+                                                 subst-15318)))
+                                     (cons (cons #f (car w-15432))
+                                           (cons 'shift (cdr w-15432))))
+                                   mod-15209)
+                                 results-15424))))))
+                  (f-15322
+                    symnames-15319
+                    marks-15320
+                    results-15321))))
+            (scan-vector-rib-15212
+              (lambda (subst-15433
+                       symnames-15434
+                       marks-15435
+                       results-15436)
+                (let ((n-15437 (vector-length symnames-15434)))
                   (letrec*
-                    ((f-16508
-                       (lambda (i-16591 results-16592)
-                         (if (= i-16591 n-16507)
-                           (scan-16280 (cdr subst-16503) results-16592)
-                           (f-16508
-                             (#{1+}# i-16591)
-                             (cons (wrap-4324
-                                     (vector-ref symnames-16504 i-16591)
-                                     (let ((w-16600
+                    ((f-15438
+                       (lambda (i-15521 results-15522)
+                         (if (= i-15521 n-15437)
+                           (scan-15210 (cdr subst-15433) results-15522)
+                           (f-15438
+                             (#{1+}# i-15521)
+                             (cons (wrap-4290
+                                     (vector-ref symnames-15434 i-15521)
+                                     (let ((w-15530
                                              (cons (vector-ref
-                                                     marks-16505
-                                                     i-16591)
-                                                   subst-16503)))
-                                       (cons (cons #f (car w-16600))
-                                             (cons 'shift (cdr w-16600))))
-                                     mod-16279)
-                                   results-16592))))))
-                    (f-16508 0 results-16506))))))
-           (scan-16280 (cdr w-16278) '()))))
-     (valid-bound-ids?-4321
-       (lambda (ids-16601)
+                                                     marks-15435
+                                                     i-15521)
+                                                   subst-15433)))
+                                       (cons (cons #f (car w-15530))
+                                             (cons 'shift (cdr w-15530))))
+                                     mod-15209)
+                                   results-15522))))))
+                    (f-15438 0 results-15436))))))
+           (scan-15210 (cdr w-15208) '()))))
+     (valid-bound-ids?-4287
+       (lambda (ids-15531)
          (if (letrec*
-               ((all-ids?-16602
-                  (lambda (ids-16764)
-                    (if (null? ids-16764)
-                      (null? ids-16764)
-                      (if (let ((x-16775 (car ids-16764)))
-                            (if (symbol? x-16775)
+               ((all-ids?-15532
+                  (lambda (ids-15694)
+                    (if (null? ids-15694)
+                      (null? ids-15694)
+                      (if (let ((x-15705 (car ids-15694)))
+                            (if (symbol? x-15705)
                               #t
-                              (if (if (vector? x-16775)
-                                    (if (= (vector-length x-16775) 4)
-                                      (eq? (vector-ref x-16775 0)
+                              (if (if (vector? x-15705)
+                                    (if (= (vector-length x-15705) 4)
+                                      (eq? (vector-ref x-15705 0)
                                            'syntax-object)
                                       #f)
                                     #f)
-                                (symbol? (vector-ref x-16775 1))
+                                (symbol? (vector-ref x-15705 1))
                                 #f)))
-                        (all-ids?-16602 (cdr ids-16764))
+                        (all-ids?-15532 (cdr ids-15694))
                         #f)))))
-               (all-ids?-16602 ids-16601))
-           (distinct-bound-ids?-4322 ids-16601)
+               (all-ids?-15532 ids-15531))
+           (distinct-bound-ids?-4288 ids-15531)
            #f)))
-     (distinct-bound-ids?-4322
-       (lambda (ids-16903)
+     (distinct-bound-ids?-4288
+       (lambda (ids-15833)
          (letrec*
-           ((distinct?-16904
-              (lambda (ids-17016)
-                (if (null? ids-17016)
-                  (null? ids-17016)
-                  (if (not (bound-id-member?-4323
-                             (car ids-17016)
-                             (cdr ids-17016)))
-                    (distinct?-16904 (cdr ids-17016))
+           ((distinct?-15834
+              (lambda (ids-15946)
+                (if (null? ids-15946)
+                  (null? ids-15946)
+                  (if (not (bound-id-member?-4289
+                             (car ids-15946)
+                             (cdr ids-15946)))
+                    (distinct?-15834 (cdr ids-15946))
                     #f)))))
-           (distinct?-16904 ids-16903))))
-     (bound-id-member?-4323
-       (lambda (x-17226 list-17227)
-         (if (not (null? list-17227))
-           (let ((t-17228
-                   (let ((j-17309 (car list-17227)))
-                     (if (if (if (vector? x-17226)
-                               (if (= (vector-length x-17226) 4)
-                                 (eq? (vector-ref x-17226 0) 'syntax-object)
+           (distinct?-15834 ids-15833))))
+     (bound-id-member?-4289
+       (lambda (x-16156 list-16157)
+         (if (not (null? list-16157))
+           (let ((t-16158
+                   (let ((j-16239 (car list-16157)))
+                     (if (if (if (vector? x-16156)
+                               (if (= (vector-length x-16156) 4)
+                                 (eq? (vector-ref x-16156 0) 'syntax-object)
                                  #f)
                                #f)
-                           (if (vector? j-17309)
-                             (if (= (vector-length j-17309) 4)
-                               (eq? (vector-ref j-17309 0) 'syntax-object)
+                           (if (vector? j-16239)
+                             (if (= (vector-length j-16239) 4)
+                               (eq? (vector-ref j-16239 0) 'syntax-object)
                                #f)
                              #f)
                            #f)
-                       (if (eq? (vector-ref x-17226 1)
-                                (vector-ref j-17309 1))
-                         (same-marks?-4313
-                           (car (vector-ref x-17226 2))
-                           (car (vector-ref j-17309 2)))
+                       (if (eq? (vector-ref x-16156 1)
+                                (vector-ref j-16239 1))
+                         (same-marks?-4279
+                           (car (vector-ref x-16156 2))
+                           (car (vector-ref j-16239 2)))
                          #f)
-                       (eq? x-17226 j-17309)))))
-             (if t-17228
-               t-17228
-               (bound-id-member?-4323 x-17226 (cdr list-17227))))
+                       (eq? x-16156 j-16239)))))
+             (if t-16158
+               t-16158
+               (bound-id-member?-4289 x-16156 (cdr list-16157))))
            #f)))
-     (wrap-4324
-       (lambda (x-17353 w-17354 defmod-17355)
-         (if (if (null? (car w-17354))
-               (null? (cdr w-17354))
+     (wrap-4290
+       (lambda (x-16283 w-16284 defmod-16285)
+         (if (if (null? (car w-16284))
+               (null? (cdr w-16284))
                #f)
-           x-17353
-           (if (if (vector? x-17353)
-                 (if (= (vector-length x-17353) 4)
-                   (eq? (vector-ref x-17353 0) 'syntax-object)
+           x-16283
+           (if (if (vector? x-16283)
+                 (if (= (vector-length x-16283) 4)
+                   (eq? (vector-ref x-16283 0) 'syntax-object)
                    #f)
                  #f)
-             (let ((expression-17369 (vector-ref x-17353 1))
-                   (wrap-17370
-                     (join-wraps-4311 w-17354 (vector-ref x-17353 2)))
-                   (module-17371 (vector-ref x-17353 3)))
+             (let ((expression-16299 (vector-ref x-16283 1))
+                   (wrap-16300
+                     (join-wraps-4277 w-16284 (vector-ref x-16283 2)))
+                   (module-16301 (vector-ref x-16283 3)))
                (vector
                  'syntax-object
-                 expression-17369
-                 wrap-17370
-                 module-17371))
-             (if (null? x-17353)
-               x-17353
+                 expression-16299
+                 wrap-16300
+                 module-16301))
+             (if (null? x-16283)
+               x-16283
                (vector
                  'syntax-object
-                 x-17353
-                 w-17354
-                 defmod-17355))))))
-     (source-wrap-4325
-       (lambda (x-17388 w-17389 s-17390 defmod-17391)
-         (wrap-4324
+                 x-16283
+                 w-16284
+                 defmod-16285))))))
+     (source-wrap-4291
+       (lambda (x-16318 w-16319 s-16320 defmod-16321)
+         (wrap-4290
            (begin
-             (if (if s-17390
-                   (supports-source-properties? x-17388)
+             (if (if s-16320
+                   (supports-source-properties? x-16318)
                    #f)
-               (set-source-properties! x-17388 s-17390))
-             x-17388)
-           w-17389
-           defmod-17391)))
-     (expand-sequence-4326
-       (lambda (body-27527 r-27528 w-27529 s-27530 mod-27531)
-         (build-sequence-4276
-           s-27530
+               (set-source-properties! x-16318 s-16320))
+             x-16318)
+           w-16319
+           defmod-16321)))
+     (expand-sequence-4292
+       (lambda (body-24664 r-24665 w-24666 s-24667 mod-24668)
+         (build-sequence-4242
+           s-24667
            (letrec*
-             ((dobody-27611
-                (lambda (body-27951 r-27952 w-27953 mod-27954)
-                  (if (null? body-27951)
+             ((dobody-24791
+                (lambda (body-25066 r-25067 w-25068 mod-25069)
+                  (if (null? body-25066)
                     '()
-                    (let ((first-27955
-                            (let ((e-27959 (car body-27951)))
+                    (let ((first-25070
+                            (let ((e-25120 (car body-25066)))
                               (call-with-values
                                 (lambda ()
-                                  (syntax-type-4330
-                                    e-27959
-                                    r-27952
-                                    w-27953
-                                    (source-annotation-4288 e-27959)
+                                  (syntax-type-4296
+                                    e-25120
+                                    r-25067
+                                    w-25068
+                                    (let ((props-25130
+                                            (source-properties
+                                              (if (if (vector? e-25120)
+                                                    (if (= (vector-length
+                                                             e-25120)
+                                                           4)
+                                                      (eq? (vector-ref
+                                                             e-25120
+                                                             0)
+                                                           'syntax-object)
+                                                      #f)
+                                                    #f)
+                                                (vector-ref e-25120 1)
+                                                e-25120))))
+                                      (if (pair? props-25130) props-25130 #f))
                                     #f
-                                    mod-27954
+                                    mod-25069
                                     #f))
-                                (lambda (type-27966
-                                         value-27967
-                                         form-27968
-                                         e-27969
-                                         w-27970
-                                         s-27971
-                                         mod-27972)
-                                  (expand-expr-4332
-                                    type-27966
-                                    value-27967
-                                    form-27968
-                                    e-27969
-                                    r-27952
-                                    w-27970
-                                    s-27971
-                                    mod-27972))))))
-                      (cons first-27955
-                            (dobody-27611
-                              (cdr body-27951)
-                              r-27952
-                              w-27953
-                              mod-27954)))))))
-             (dobody-27611
-               body-27527
-               r-27528
-               w-27529
-               mod-27531)))))
-     (expand-top-sequence-4327
-       (lambda (body-17409
-                r-17410
-                w-17411
-                s-17412
-                m-17413
-                esew-17414
-                mod-17415)
+                                (lambda (type-25153
+                                         value-25154
+                                         form-25155
+                                         e-25156
+                                         w-25157
+                                         s-25158
+                                         mod-25159)
+                                  (expand-expr-4298
+                                    type-25153
+                                    value-25154
+                                    form-25155
+                                    e-25156
+                                    r-25067
+                                    w-25157
+                                    s-25158
+                                    mod-25159))))))
+                      (cons first-25070
+                            (dobody-24791
+                              (cdr body-25066)
+                              r-25067
+                              w-25068
+                              mod-25069)))))))
+             (dobody-24791
+               body-24664
+               r-24665
+               w-24666
+               mod-24668)))))
+     (expand-top-sequence-4293
+       (lambda (body-16339
+                r-16340
+                w-16341
+                s-16342
+                m-16343
+                esew-16344
+                mod-16345)
          (letrec*
-           ((scan-17416
-              (lambda (body-17547
-                       r-17548
-                       w-17549
-                       s-17550
-                       m-17551
-                       esew-17552
-                       mod-17553
-                       exps-17554)
-                (if (null? body-17547)
-                  exps-17554
+           ((scan-16346
+              (lambda (body-16477
+                       r-16478
+                       w-16479
+                       s-16480
+                       m-16481
+                       esew-16482
+                       mod-16483
+                       exps-16484)
+                (if (null? body-16477)
+                  exps-16484
                   (call-with-values
                     (lambda ()
                       (call-with-values
                         (lambda ()
-                          (let ((e-17555 (car body-17547)))
-                            (syntax-type-4330
-                              e-17555
-                              r-17548
-                              w-17549
-                              (let ((t-17559 (source-annotation-4288 e-17555)))
-                                (if t-17559 t-17559 s-17550))
+                          (let ((e-16485 (car body-16477)))
+                            (syntax-type-4296
+                              e-16485
+                              r-16478
+                              w-16479
+                              (let ((t-16489
+                                      (let ((props-16521
+                                              (source-properties
+                                                (if (if (vector? e-16485)
+                                                      (if (= (vector-length
+                                                               e-16485)
+                                                             4)
+                                                        (eq? (vector-ref
+                                                               e-16485
+                                                               0)
+                                                             'syntax-object)
+                                                        #f)
+                                                      #f)
+                                                  (vector-ref e-16485 1)
+                                                  e-16485))))
+                                        (if (pair? props-16521)
+                                          props-16521
+                                          #f))))
+                                (if t-16489 t-16489 s-16480))
                               #f
-                              mod-17553
+                              mod-16483
                               #f)))
-                        (lambda (type-17794
-                                 value-17795
-                                 form-17796
-                                 e-17797
-                                 w-17798
-                                 s-17799
-                                 mod-17800)
-                          (if (eqv? type-17794 'begin-form)
-                            (let ((tmp-17809 ($sc-dispatch e-17797 '(_))))
-                              (if tmp-17809
-                                (@apply (lambda () exps-17554) tmp-17809)
-                                (let ((tmp-17813
+                        (lambda (type-16544
+                                 value-16545
+                                 form-16546
+                                 e-16547
+                                 w-16548
+                                 s-16549
+                                 mod-16550)
+                          (if (eqv? type-16544 'begin-form)
+                            (let ((tmp-16559 ($sc-dispatch e-16547 '(_))))
+                              (if tmp-16559
+                                (@apply (lambda () exps-16484) tmp-16559)
+                                (let ((tmp-16563
                                         ($sc-dispatch
-                                          e-17797
+                                          e-16547
                                           '(_ any . each-any))))
-                                  (if tmp-17813
+                                  (if tmp-16563
                                     (@apply
-                                      (lambda (e1-17817 e2-17818)
-                                        (scan-17416
-                                          (cons e1-17817 e2-17818)
-                                          r-17548
-                                          w-17798
-                                          s-17799
-                                          m-17551
-                                          esew-17552
-                                          mod-17800
-                                          exps-17554))
-                                      tmp-17813)
+                                      (lambda (e1-16567 e2-16568)
+                                        (scan-16346
+                                          (cons e1-16567 e2-16568)
+                                          r-16478
+                                          w-16548
+                                          s-16549
+                                          m-16481
+                                          esew-16482
+                                          mod-16550
+                                          exps-16484))
+                                      tmp-16563)
                                     (syntax-violation
                                       #f
                                       "source expression failed to match any 
pattern"
-                                      e-17797)))))
-                            (if (eqv? type-17794 'local-syntax-form)
-                              (expand-local-syntax-4336
-                                value-17795
-                                e-17797
-                                r-17548
-                                w-17798
-                                s-17799
-                                mod-17800
-                                (lambda (body-17836
-                                         r-17837
-                                         w-17838
-                                         s-17839
-                                         mod-17840)
-                                  (scan-17416
-                                    body-17836
-                                    r-17837
-                                    w-17838
-                                    s-17839
-                                    m-17551
-                                    esew-17552
-                                    mod-17840
-                                    exps-17554)))
-                              (if (eqv? type-17794 'eval-when-form)
-                                (let ((tmp-17848
+                                      e-16547)))))
+                            (if (eqv? type-16544 'local-syntax-form)
+                              (expand-local-syntax-4302
+                                value-16545
+                                e-16547
+                                r-16478
+                                w-16548
+                                s-16549
+                                mod-16550
+                                (lambda (body-16586
+                                         r-16587
+                                         w-16588
+                                         s-16589
+                                         mod-16590)
+                                  (scan-16346
+                                    body-16586
+                                    r-16587
+                                    w-16588
+                                    s-16589
+                                    m-16481
+                                    esew-16482
+                                    mod-16590
+                                    exps-16484)))
+                              (if (eqv? type-16544 'eval-when-form)
+                                (let ((tmp-16598
                                         ($sc-dispatch
-                                          e-17797
+                                          e-16547
                                           '(_ each-any any . each-any))))
-                                  (if tmp-17848
+                                  (if tmp-16598
                                     (@apply
-                                      (lambda (x-17852 e1-17853 e2-17854)
-                                        (let ((when-list-17855
-                                                (parse-when-list-4329
-                                                  e-17797
-                                                  x-17852))
-                                              (body-17856
-                                                (cons e1-17853 e2-17854)))
-                                          (if (eq? m-17551 'e)
-                                            (if (memq 'eval when-list-17855)
-                                              (scan-17416
-                                                body-17856
-                                                r-17548
-                                                w-17798
-                                                s-17799
+                                      (lambda (x-16602 e1-16603 e2-16604)
+                                        (let ((when-list-16605
+                                                (parse-when-list-4295
+                                                  e-16547
+                                                  x-16602))
+                                              (body-16606
+                                                (cons e1-16603 e2-16604)))
+                                          (if (eq? m-16481 'e)
+                                            (if (memq 'eval when-list-16605)
+                                              (scan-16346
+                                                body-16606
+                                                r-16478
+                                                w-16548
+                                                s-16549
                                                 (if (memq 'expand
-                                                          when-list-17855)
+                                                          when-list-16605)
                                                   'c&e
                                                   'e)
                                                 '(eval)
-                                                mod-17800
-                                                exps-17554)
+                                                mod-16550
+                                                exps-16484)
                                               (begin
                                                 (if (memq 'expand
-                                                          when-list-17855)
-                                                  (let ((x-17933
-                                                          
(expand-top-sequence-4327
-                                                            body-17856
-                                                            r-17548
-                                                            w-17798
-                                                            s-17799
+                                                          when-list-16605)
+                                                  (let ((x-16683
+                                                          
(expand-top-sequence-4293
+                                                            body-16606
+                                                            r-16478
+                                                            w-16548
+                                                            s-16549
                                                             'e
                                                             '(eval)
-                                                            mod-17800)))
-                                                    (primitive-eval x-17933)))
-                                                exps-17554))
-                                            (if (memq 'load when-list-17855)
-                                              (if (let ((t-17959
+                                                            mod-16550)))
+                                                    (primitive-eval x-16683)))
+                                                exps-16484))
+                                            (if (memq 'load when-list-16605)
+                                              (if (let ((t-16709
                                                           (memq 'compile
-                                                                
when-list-17855)))
-                                                    (if t-17959
-                                                      t-17959
-                                                      (let ((t-18008
+                                                                
when-list-16605)))
+                                                    (if t-16709
+                                                      t-16709
+                                                      (let ((t-16758
                                                               (memq 'expand
-                                                                    
when-list-17855)))
-                                                        (if t-18008
-                                                          t-18008
-                                                          (if (eq? m-17551
+                                                                    
when-list-16605)))
+                                                        (if t-16758
+                                                          t-16758
+                                                          (if (eq? m-16481
                                                                    'c&e)
                                                             (memq 'eval
-                                                                  
when-list-17855)
+                                                                  
when-list-16605)
                                                             #f)))))
-                                                (scan-17416
-                                                  body-17856
-                                                  r-17548
-                                                  w-17798
-                                                  s-17799
+                                                (scan-16346
+                                                  body-16606
+                                                  r-16478
+                                                  w-16548
+                                                  s-16549
                                                   'c&e
                                                   '(compile load)
-                                                  mod-17800
-                                                  exps-17554)
-                                                (if (if (eq? m-17551 'c)
+                                                  mod-16550
+                                                  exps-16484)
+                                                (if (if (eq? m-16481 'c)
                                                       #t
-                                                      (eq? m-17551 'c&e))
-                                                  (scan-17416
-                                                    body-17856
-                                                    r-17548
-                                                    w-17798
-                                                    s-17799
+                                                      (eq? m-16481 'c&e))
+                                                  (scan-16346
+                                                    body-16606
+                                                    r-16478
+                                                    w-16548
+                                                    s-16549
                                                     'c
                                                     '(load)
-                                                    mod-17800
-                                                    exps-17554)
-                                                  exps-17554))
-                                              (if (let ((t-18137
+                                                    mod-16550
+                                                    exps-16484)
+                                                  exps-16484))
+                                              (if (let ((t-16887
                                                           (memq 'compile
-                                                                
when-list-17855)))
-                                                    (if t-18137
-                                                      t-18137
-                                                      (let ((t-18186
+                                                                
when-list-16605)))
+                                                    (if t-16887
+                                                      t-16887
+                                                      (let ((t-16936
                                                               (memq 'expand
-                                                                    
when-list-17855)))
-                                                        (if t-18186
-                                                          t-18186
-                                                          (if (eq? m-17551
+                                                                    
when-list-16605)))
+                                                        (if t-16936
+                                                          t-16936
+                                                          (if (eq? m-16481
                                                                    'c&e)
                                                             (memq 'eval
-                                                                  
when-list-17855)
+                                                                  
when-list-16605)
                                                             #f)))))
                                                 (begin
-                                                  (let ((x-18310
-                                                          
(expand-top-sequence-4327
-                                                            body-17856
-                                                            r-17548
-                                                            w-17798
-                                                            s-17799
+                                                  (let ((x-17060
+                                                          
(expand-top-sequence-4293
+                                                            body-16606
+                                                            r-16478
+                                                            w-16548
+                                                            s-16549
                                                             'e
                                                             '(eval)
-                                                            mod-17800)))
-                                                    (primitive-eval x-18310))
-                                                  exps-17554)
-                                                exps-17554)))))
-                                      tmp-17848)
+                                                            mod-16550)))
+                                                    (primitive-eval x-17060))
+                                                  exps-16484)
+                                                exps-16484)))))
+                                      tmp-16598)
                                     (syntax-violation
                                       #f
                                       "source expression failed to match any 
pattern"
-                                      e-17797)))
-                                (if (if (eqv? type-17794 'define-syntax-form)
+                                      e-16547)))
+                                (if (if (eqv? type-16544 'define-syntax-form)
                                       #t
-                                      (eqv? type-17794
+                                      (eqv? type-16544
                                             'define-syntax-parameter-form))
-                                  (let ((n-18359
-                                          (id-var-name-4314
-                                            value-17795
-                                            w-17798))
-                                        (r-18360
-                                          (macros-only-env-4291 r-17548)))
-                                    (if (eqv? m-17551 'c)
-                                      (if (memq 'compile esew-17552)
-                                        (let ((e-18368
-                                                (expand-install-global-4328
-                                                  n-18359
-                                                  (expand-4331
-                                                    e-17797
-                                                    r-18360
-                                                    w-17798
-                                                    mod-17800))))
+                                  (let ((n-17109
+                                          (id-var-name-4280
+                                            value-16545
+                                            w-16548))
+                                        (r-17110
+                                          (macros-only-env-4257 r-16478)))
+                                    (if (eqv? m-16481 'c)
+                                      (if (memq 'compile esew-16482)
+                                        (let ((e-17118
+                                                (expand-install-global-4294
+                                                  n-17109
+                                                  (call-with-values
+                                                    (lambda ()
+                                                      (syntax-type-4296
+                                                        e-16547
+                                                        r-17110
+                                                        w-16548
+                                                        (let ((props-17391
+                                                                
(source-properties
+                                                                  (if (if 
(vector?
+                                                                            
e-16547)
+                                                                        (if (= 
(vector-length
+                                                                               
  e-16547)
+                                                                               
4)
+                                                                          (eq? 
(vector-ref
+                                                                               
  e-16547
+                                                                               
  0)
+                                                                               
'syntax-object)
+                                                                          #f)
+                                                                        #f)
+                                                                    (vector-ref
+                                                                      e-16547
+                                                                      1)
+                                                                    e-16547))))
+                                                          (if (pair? 
props-17391)
+                                                            props-17391
+                                                            #f))
+                                                        #f
+                                                        mod-16550
+                                                        #f))
+                                                    (lambda (type-17424
+                                                             value-17425
+                                                             form-17426
+                                                             e-17427
+                                                             w-17428
+                                                             s-17429
+                                                             mod-17430)
+                                                      (expand-expr-4298
+                                                        type-17424
+                                                        value-17425
+                                                        form-17426
+                                                        e-17427
+                                                        r-17110
+                                                        w-17428
+                                                        s-17429
+                                                        mod-17430))))))
                                           (begin
-                                            (top-level-eval-hook-4254
-                                              e-18368
-                                              mod-17800)
-                                            (if (memq 'load esew-17552)
-                                              (cons e-18368 exps-17554)
-                                              exps-17554)))
-                                        (if (memq 'load esew-17552)
-                                          (cons (expand-install-global-4328
-                                                  n-18359
-                                                  (expand-4331
-                                                    e-17797
-                                                    r-18360
-                                                    w-17798
-                                                    mod-17800))
-                                                exps-17554)
-                                          exps-17554))
-                                      (if (eqv? m-17551 'c&e)
-                                        (let ((e-19013
-                                                (expand-install-global-4328
-                                                  n-18359
-                                                  (expand-4331
-                                                    e-17797
-                                                    r-18360
-                                                    w-17798
-                                                    mod-17800))))
+                                            (top-level-eval-hook-4220
+                                              e-17118
+                                              mod-16550)
+                                            (if (memq 'load esew-16482)
+                                              (cons e-17118 exps-16484)
+                                              exps-16484)))
+                                        (if (memq 'load esew-16482)
+                                          (cons (expand-install-global-4294
+                                                  n-17109
+                                                  (call-with-values
+                                                    (lambda ()
+                                                      (syntax-type-4296
+                                                        e-16547
+                                                        r-17110
+                                                        w-16548
+                                                        (let ((props-17660
+                                                                
(source-properties
+                                                                  (if (if 
(vector?
+                                                                            
e-16547)
+                                                                        (if (= 
(vector-length
+                                                                               
  e-16547)
+                                                                               
4)
+                                                                          (eq? 
(vector-ref
+                                                                               
  e-16547
+                                                                               
  0)
+                                                                               
'syntax-object)
+                                                                          #f)
+                                                                        #f)
+                                                                    (vector-ref
+                                                                      e-16547
+                                                                      1)
+                                                                    e-16547))))
+                                                          (if (pair? 
props-17660)
+                                                            props-17660
+                                                            #f))
+                                                        #f
+                                                        mod-16550
+                                                        #f))
+                                                    (lambda (type-17662
+                                                             value-17663
+                                                             form-17664
+                                                             e-17665
+                                                             w-17666
+                                                             s-17667
+                                                             mod-17668)
+                                                      (expand-expr-4298
+                                                        type-17662
+                                                        value-17663
+                                                        form-17664
+                                                        e-17665
+                                                        r-17110
+                                                        w-17666
+                                                        s-17667
+                                                        mod-17668))))
+                                                exps-16484)
+                                          exps-16484))
+                                      (if (eqv? m-16481 'c&e)
+                                        (let ((e-17677
+                                                (expand-install-global-4294
+                                                  n-17109
+                                                  (call-with-values
+                                                    (lambda ()
+                                                      (syntax-type-4296
+                                                        e-16547
+                                                        r-17110
+                                                        w-16548
+                                                        (let ((props-17949
+                                                                
(source-properties
+                                                                  (if (if 
(vector?
+                                                                            
e-16547)
+                                                                        (if (= 
(vector-length
+                                                                               
  e-16547)
+                                                                               
4)
+                                                                          (eq? 
(vector-ref
+                                                                               
  e-16547
+                                                                               
  0)
+                                                                               
'syntax-object)
+                                                                          #f)
+                                                                        #f)
+                                                                    (vector-ref
+                                                                      e-16547
+                                                                      1)
+                                                                    e-16547))))
+                                                          (if (pair? 
props-17949)
+                                                            props-17949
+                                                            #f))
+                                                        #f
+                                                        mod-16550
+                                                        #f))
+                                                    (lambda (type-17982
+                                                             value-17983
+                                                             form-17984
+                                                             e-17985
+                                                             w-17986
+                                                             s-17987
+                                                             mod-17988)
+                                                      (expand-expr-4298
+                                                        type-17982
+                                                        value-17983
+                                                        form-17984
+                                                        e-17985
+                                                        r-17110
+                                                        w-17986
+                                                        s-17987
+                                                        mod-17988))))))
                                           (begin
-                                            (top-level-eval-hook-4254
-                                              e-19013
-                                              mod-17800)
-                                            (cons e-19013 exps-17554)))
+                                            (top-level-eval-hook-4220
+                                              e-17677
+                                              mod-16550)
+                                            (cons e-17677 exps-16484)))
                                         (begin
-                                          (if (memq 'eval esew-17552)
-                                            (top-level-eval-hook-4254
-                                              (expand-install-global-4328
-                                                n-18359
-                                                (expand-4331
-                                                  e-17797
-                                                  r-18360
-                                                  w-17798
-                                                  mod-17800))
-                                              mod-17800))
-                                          exps-17554))))
-                                  (if (eqv? type-17794 'define-form)
-                                    (let ((n-19690
-                                            (id-var-name-4314
-                                              value-17795
-                                              w-17798)))
-                                      (let ((type-19691
-                                              (car (let ((t-19699
-                                                           (assq n-19690
-                                                                 r-17548)))
-                                                     (if t-19699
-                                                       (cdr t-19699)
-                                                       (if (symbol? n-19690)
-                                                         (let ((t-19705
-                                                                 
(get-global-definition-hook-4258
-                                                                   n-19690
-                                                                   mod-17800)))
-                                                           (if t-19705
-                                                             t-19705
+                                          (if (memq 'eval esew-16482)
+                                            (top-level-eval-hook-4220
+                                              (let ((e-18087
+                                                      (call-with-values
+                                                        (lambda ()
+                                                          (syntax-type-4296
+                                                            e-16547
+                                                            r-17110
+                                                            w-16548
+                                                            (let ((props-18152
+                                                                    
(source-properties
+                                                                      (if (if 
(vector?
+                                                                               
 e-16547)
+                                                                            
(if (= (vector-length
+                                                                               
      e-16547)
+                                                                               
    4)
+                                                                              
(eq? (vector-ref
+                                                                               
      e-16547
+                                                                               
      0)
+                                                                               
    'syntax-object)
+                                                                              
#f)
+                                                                            #f)
+                                                                        
(vector-ref
+                                                                          
e-16547
+                                                                          1)
+                                                                        
e-16547))))
+                                                              (if (pair? 
props-18152)
+                                                                props-18152
+                                                                #f))
+                                                            #f
+                                                            mod-16550
+                                                            #f))
+                                                        (lambda (type-18185
+                                                                 value-18186
+                                                                 form-18187
+                                                                 e-18188
+                                                                 w-18189
+                                                                 s-18190
+                                                                 mod-18191)
+                                                          (expand-expr-4298
+                                                            type-18185
+                                                            value-18186
+                                                            form-18187
+                                                            e-18188
+                                                            r-17110
+                                                            w-18189
+                                                            s-18190
+                                                            mod-18191)))))
+                                                (let ((exp-18092
+                                                        (let ((fun-exp-18102
+                                                                (if (equal?
+                                                                      
(module-name
+                                                                        
(current-module))
+                                                                      '(guile))
+                                                                  
(make-struct/no-tail
+                                                                    (vector-ref
+                                                                      
%expanded-vtables
+                                                                      7)
+                                                                    #f
+                                                                    
'make-syntax-transformer)
+                                                                  
(make-struct/no-tail
+                                                                    (vector-ref
+                                                                      
%expanded-vtables
+                                                                      5)
+                                                                    #f
+                                                                    '(guile)
+                                                                    
'make-syntax-transformer
+                                                                    #f)))
+                                                              (arg-exps-18103
+                                                                (list 
(make-struct/no-tail
+                                                                        
(vector-ref
+                                                                          
%expanded-vtables
+                                                                          1)
+                                                                        #f
+                                                                        
n-17109)
+                                                                      
(make-struct/no-tail
+                                                                        
(vector-ref
+                                                                          
%expanded-vtables
+                                                                          1)
+                                                                        #f
+                                                                        'macro)
+                                                                      
e-18087)))
+                                                          (make-struct/no-tail
+                                                            (vector-ref
+                                                              %expanded-vtables
+                                                              11)
+                                                            #f
+                                                            fun-exp-18102
+                                                            arg-exps-18103))))
+                                                  (begin
+                                                    (if (if (struct? exp-18092)
+                                                          (eq? (struct-vtable
+                                                                 exp-18092)
+                                                               (vector-ref
+                                                                 
%expanded-vtables
+                                                                 13))
+                                                          #f)
+                                                      (let ((meta-18203
+                                                              (struct-ref
+                                                                exp-18092
+                                                                1)))
+                                                        (if (not (assq 'name
+                                                                       
meta-18203))
+                                                          (let ((v-18210
+                                                                  (cons (cons 
'name
+                                                                              
n-17109)
+                                                                        
meta-18203)))
+                                                            (struct-set!
+                                                              exp-18092
+                                                              1
+                                                              v-18210)))))
+                                                    (make-struct/no-tail
+                                                      (vector-ref
+                                                        %expanded-vtables
+                                                        9)
+                                                      #f
+                                                      n-17109
+                                                      exp-18092))))
+                                              mod-16550))
+                                          exps-16484))))
+                                  (if (eqv? type-16544 'define-form)
+                                    (let ((n-18293
+                                            (id-var-name-4280
+                                              value-16545
+                                              w-16548)))
+                                      (let ((type-18294
+                                              (car (let ((t-18302
+                                                           (assq n-18293
+                                                                 r-16478)))
+                                                     (if t-18302
+                                                       (cdr t-18302)
+                                                       (if (symbol? n-18293)
+                                                         (let ((t-18308
+                                                                 
(get-global-definition-hook-4224
+                                                                   n-18293
+                                                                   mod-16550)))
+                                                           (if t-18308
+                                                             t-18308
                                                              '(global)))
                                                          
'(displaced-lexical)))))))
-                                        (if (if (eqv? type-19691 'global)
+                                        (if (if (eqv? type-18294 'global)
                                               #t
-                                              (if (eqv? type-19691 'core)
+                                              (if (eqv? type-18294 'core)
                                                 #t
-                                                (if (eqv? type-19691 'macro)
+                                                (if (eqv? type-18294 'macro)
                                                   #t
-                                                  (eqv? type-19691
+                                                  (eqv? type-18294
                                                         'module-ref))))
                                           (begin
-                                            (if (if (if (eq? m-17551 'c)
+                                            (if (if (if (eq? m-16481 'c)
                                                       #t
-                                                      (eq? m-17551 'c&e))
+                                                      (eq? m-16481 'c&e))
                                                   (if (not 
(module-local-variable
                                                              (current-module)
-                                                             n-19690))
+                                                             n-18293))
                                                     (current-module)
                                                     #f)
                                                   #f)
-                                              (let ((old-19738
+                                              (let ((old-18341
                                                       (module-variable
                                                         (current-module)
-                                                        n-19690)))
-                                                (if (if (variable? old-19738)
+                                                        n-18293)))
+                                                (if (if (variable? old-18341)
                                                       (variable-bound?
-                                                        old-19738)
+                                                        old-18341)
                                                       #f)
                                                   (module-define!
                                                     (current-module)
-                                                    n-19690
-                                                    (variable-ref old-19738))
+                                                    n-18293
+                                                    (variable-ref old-18341))
                                                   (module-add!
                                                     (current-module)
-                                                    n-19690
+                                                    n-18293
                                                     
(make-undefined-variable)))))
-                                            (cons (if (eq? m-17551 'c&e)
-                                                    (let ((x-20179
-                                                            
(build-global-definition-4270
-                                                              s-17799
-                                                              n-19690
-                                                              (expand-4331
-                                                                e-17797
-                                                                r-17548
-                                                                w-17798
-                                                                mod-17800))))
+                                            (cons (if (eq? m-16481 'c&e)
+                                                    (let ((x-18538
+                                                            (let ((exp-18567
+                                                                    
(call-with-values
+                                                                      (lambda 
()
+                                                                        
(syntax-type-4296
+                                                                          
e-16547
+                                                                          
r-16478
+                                                                          
w-16548
+                                                                          (let 
((props-18570
+                                                                               
   (source-properties
+                                                                               
     (if (if (vector?
+                                                                               
               e-16547)
+                                                                               
           (if (= (vector-length
+                                                                               
                    e-16547)
+                                                                               
                  4)
+                                                                               
             (eq? (vector-ref
+                                                                               
                    e-16547
+                                                                               
                    0)
+                                                                               
                  'syntax-object)
+                                                                               
             #f)
+                                                                               
           #f)
+                                                                               
       (vector-ref
+                                                                               
         e-16547
+                                                                               
         1)
+                                                                               
       e-16547))))
+                                                                            
(if (pair? props-18570)
+                                                                              
props-18570
+                                                                              
#f))
+                                                                          #f
+                                                                          
mod-16550
+                                                                          #f))
+                                                                      (lambda 
(type-18571
+                                                                               
value-18572
+                                                                               
form-18573
+                                                                               
e-18574
+                                                                               
w-18575
+                                                                               
s-18576
+                                                                               
mod-18577)
+                                                                        
(expand-expr-4298
+                                                                          
type-18571
+                                                                          
value-18572
+                                                                          
form-18573
+                                                                          
e-18574
+                                                                          
r-16478
+                                                                          
w-18575
+                                                                          
s-18576
+                                                                          
mod-18577)))))
+                                                              (begin
+                                                                (if (if 
(struct?
+                                                                          
exp-18567)
+                                                                      (eq? 
(struct-vtable
+                                                                             
exp-18567)
+                                                                           
(vector-ref
+                                                                             
%expanded-vtables
+                                                                             
13))
+                                                                      #f)
+                                                                  (let 
((meta-18579
+                                                                          
(struct-ref
+                                                                            
exp-18567
+                                                                            
1)))
+                                                                    (if (not 
(assq 'name
+                                                                               
    meta-18579))
+                                                                      (let 
((v-18581
+                                                                              
(cons (cons 'name
+                                                                               
           n-18293)
+                                                                               
     meta-18579)))
+                                                                        
(struct-set!
+                                                                          
exp-18567
+                                                                          1
+                                                                          
v-18581)))))
+                                                                
(make-struct/no-tail
+                                                                  (vector-ref
+                                                                    
%expanded-vtables
+                                                                    9)
+                                                                  s-16549
+                                                                  n-18293
+                                                                  
exp-18567)))))
                                                       (begin
-                                                        
(top-level-eval-hook-4254
-                                                          x-20179
-                                                          mod-17800)
-                                                        x-20179))
+                                                        (primitive-eval
+                                                          x-18538)
+                                                        x-18538))
                                                     (lambda ()
-                                                      
(build-global-definition-4270
-                                                        s-17799
-                                                        n-19690
-                                                        (expand-4331
-                                                          e-17797
-                                                          r-17548
-                                                          w-17798
-                                                          mod-17800))))
-                                                  exps-17554))
-                                          (if (eqv? type-19691
+                                                      (let ((exp-18583
+                                                              (call-with-values
+                                                                (lambda ()
+                                                                  
(syntax-type-4296
+                                                                    e-16547
+                                                                    r-16478
+                                                                    w-16548
+                                                                    (let 
((props-18586
+                                                                            
(source-properties
+                                                                              
(if (if (vector?
+                                                                               
         e-16547)
+                                                                               
     (if (= (vector-length
+                                                                               
              e-16547)
+                                                                               
            4)
+                                                                               
       (eq? (vector-ref
+                                                                               
              e-16547
+                                                                               
              0)
+                                                                               
            'syntax-object)
+                                                                               
       #f)
+                                                                               
     #f)
+                                                                               
 (vector-ref
+                                                                               
   e-16547
+                                                                               
   1)
+                                                                               
 e-16547))))
+                                                                      (if 
(pair? props-18586)
+                                                                        
props-18586
+                                                                        #f))
+                                                                    #f
+                                                                    mod-16550
+                                                                    #f))
+                                                                (lambda 
(type-18587
+                                                                         
value-18588
+                                                                         
form-18589
+                                                                         
e-18590
+                                                                         
w-18591
+                                                                         
s-18592
+                                                                         
mod-18593)
+                                                                  
(expand-expr-4298
+                                                                    type-18587
+                                                                    value-18588
+                                                                    form-18589
+                                                                    e-18590
+                                                                    r-16478
+                                                                    w-18591
+                                                                    s-18592
+                                                                    
mod-18593)))))
+                                                        (begin
+                                                          (if (if (struct?
+                                                                    exp-18583)
+                                                                (eq? 
(struct-vtable
+                                                                       
exp-18583)
+                                                                     
(vector-ref
+                                                                       
%expanded-vtables
+                                                                       13))
+                                                                #f)
+                                                            (let ((meta-18595
+                                                                    (struct-ref
+                                                                      exp-18583
+                                                                      1)))
+                                                              (if (not (assq 
'name
+                                                                             
meta-18595))
+                                                                (let ((v-18597
+                                                                        (cons 
(cons 'name
+                                                                               
     n-18293)
+                                                                              
meta-18595)))
+                                                                  (struct-set!
+                                                                    exp-18583
+                                                                    1
+                                                                    
v-18597)))))
+                                                          (make-struct/no-tail
+                                                            (vector-ref
+                                                              %expanded-vtables
+                                                              9)
+                                                            s-16549
+                                                            n-18293
+                                                            exp-18583)))))
+                                                  exps-16484))
+                                          (if (eqv? type-18294
                                                     'displaced-lexical)
                                             (syntax-violation
                                               #f
                                               "identifier out of context"
-                                              (wrap-4324
+                                              (wrap-4290
                                                 (begin
-                                                  (if (if s-17799
+                                                  (if (if s-16549
                                                         
(supports-source-properties?
-                                                          form-17796)
+                                                          form-16546)
                                                         #f)
                                                     (set-source-properties!
-                                                      form-17796
-                                                      s-17799))
-                                                  form-17796)
-                                                w-17798
-                                                mod-17800)
-                                              (wrap-4324
-                                                value-17795
-                                                w-17798
-                                                mod-17800))
+                                                      form-16546
+                                                      s-16549))
+                                                  form-16546)
+                                                w-16548
+                                                mod-16550)
+                                              (wrap-4290
+                                                value-16545
+                                                w-16548
+                                                mod-16550))
                                             (syntax-violation
                                               #f
                                               "cannot define keyword at top 
level"
-                                              (wrap-4324
+                                              (wrap-4290
                                                 (begin
-                                                  (if (if s-17799
+                                                  (if (if s-16549
                                                         
(supports-source-properties?
-                                                          form-17796)
+                                                          form-16546)
                                                         #f)
                                                     (set-source-properties!
-                                                      form-17796
-                                                      s-17799))
-                                                  form-17796)
-                                                w-17798
-                                                mod-17800)
-                                              (wrap-4324
-                                                value-17795
-                                                w-17798
-                                                mod-17800))))))
-                                    (cons (if (eq? m-17551 'c&e)
-                                            (let ((x-20681
-                                                    (expand-expr-4332
-                                                      type-17794
-                                                      value-17795
-                                                      form-17796
-                                                      e-17797
-                                                      r-17548
-                                                      w-17798
-                                                      s-17799
-                                                      mod-17800)))
+                                                      form-16546
+                                                      s-16549))
+                                                  form-16546)
+                                                w-16548
+                                                mod-16550)
+                                              (wrap-4290
+                                                value-16545
+                                                w-16548
+                                                mod-16550))))))
+                                    (cons (if (eq? m-16481 'c&e)
+                                            (let ((x-18662
+                                                    (expand-expr-4298
+                                                      type-16544
+                                                      value-16545
+                                                      form-16546
+                                                      e-16547
+                                                      r-16478
+                                                      w-16548
+                                                      s-16549
+                                                      mod-16550)))
                                               (begin
-                                                (primitive-eval x-20681)
-                                                x-20681))
+                                                (primitive-eval x-18662)
+                                                x-18662))
                                             (lambda ()
-                                              (expand-expr-4332
-                                                type-17794
-                                                value-17795
-                                                form-17796
-                                                e-17797
-                                                r-17548
-                                                w-17798
-                                                s-17799
-                                                mod-17800)))
-                                          exps-17554)))))))))
-                    (lambda (exps-20686)
-                      (scan-17416
-                        (cdr body-17547)
-                        r-17548
-                        w-17549
-                        s-17550
-                        m-17551
-                        esew-17552
-                        mod-17553
-                        exps-20686)))))))
+                                              (expand-expr-4298
+                                                type-16544
+                                                value-16545
+                                                form-16546
+                                                e-16547
+                                                r-16478
+                                                w-16548
+                                                s-16549
+                                                mod-16550)))
+                                          exps-16484)))))))))
+                    (lambda (exps-18667)
+                      (scan-16346
+                        (cdr body-16477)
+                        r-16478
+                        w-16479
+                        s-16480
+                        m-16481
+                        esew-16482
+                        mod-16483
+                        exps-18667)))))))
            (call-with-values
              (lambda ()
-               (scan-17416
-                 body-17409
-                 r-17410
-                 w-17411
-                 s-17412
-                 m-17413
-                 esew-17414
-                 mod-17415
+               (scan-16346
+                 body-16339
+                 r-16340
+                 w-16341
+                 s-16342
+                 m-16343
+                 esew-16344
+                 mod-16345
                  '()))
-             (lambda (exps-17419)
-               (if (null? exps-17419)
+             (lambda (exps-16349)
+               (if (null? exps-16349)
                  (make-struct/no-tail
                    (vector-ref %expanded-vtables 0)
-                   s-17412)
-                 (build-sequence-4276
-                   s-17412
+                   s-16342)
+                 (build-sequence-4242
+                   s-16342
                    (letrec*
-                     ((lp-17459
-                        (lambda (in-17543 out-17544)
-                          (if (null? in-17543)
-                            out-17544
-                            (let ((e-17545 (car in-17543)))
-                              (lp-17459
-                                (cdr in-17543)
-                                (cons (if (procedure? e-17545)
-                                        (e-17545)
-                                        e-17545)
-                                      out-17544)))))))
-                     (lp-17459 exps-17419 '())))))))))
-     (expand-install-global-4328
-       (lambda (name-20687 e-20688)
-         (let ((exp-20694
-                 (let ((fun-exp-20704
+                     ((lp-16389
+                        (lambda (in-16473 out-16474)
+                          (if (null? in-16473)
+                            out-16474
+                            (let ((e-16475 (car in-16473)))
+                              (lp-16389
+                                (cdr in-16473)
+                                (cons (if (procedure? e-16475)
+                                        (e-16475)
+                                        e-16475)
+                                      out-16474)))))))
+                     (lp-16389 exps-16349 '())))))))))
+     (expand-install-global-4294
+       (lambda (name-18668 e-18669)
+         (let ((exp-18675
+                 (let ((fun-exp-18685
                          (if (equal? (module-name (current-module)) '(guile))
                            (make-struct/no-tail
                              (vector-ref %expanded-vtables 7)
@@ -1276,398 +1554,398 @@
                              '(guile)
                              'make-syntax-transformer
                              #f)))
-                       (arg-exps-20705
+                       (arg-exps-18686
                          (list (make-struct/no-tail
                                  (vector-ref %expanded-vtables 1)
                                  #f
-                                 name-20687)
+                                 name-18668)
                                (make-struct/no-tail
                                  (vector-ref %expanded-vtables 1)
                                  #f
                                  'macro)
-                               e-20688)))
+                               e-18669)))
                    (make-struct/no-tail
                      (vector-ref %expanded-vtables 11)
                      #f
-                     fun-exp-20704
-                     arg-exps-20705))))
+                     fun-exp-18685
+                     arg-exps-18686))))
            (begin
-             (if (if (struct? exp-20694)
-                   (eq? (struct-vtable exp-20694)
+             (if (if (struct? exp-18675)
+                   (eq? (struct-vtable exp-18675)
                         (vector-ref %expanded-vtables 13))
                    #f)
-               (let ((meta-20746 (struct-ref exp-20694 1)))
-                 (if (not (assq 'name meta-20746))
-                   (let ((v-20753
-                           (cons (cons 'name name-20687) meta-20746)))
-                     (struct-set! exp-20694 1 v-20753)))))
+               (let ((meta-18727 (struct-ref exp-18675 1)))
+                 (if (not (assq 'name meta-18727))
+                   (let ((v-18734
+                           (cons (cons 'name name-18668) meta-18727)))
+                     (struct-set! exp-18675 1 v-18734)))))
              (make-struct/no-tail
                (vector-ref %expanded-vtables 9)
                #f
-               name-20687
-               exp-20694)))))
-     (parse-when-list-4329
-       (lambda (e-20764 when-list-20765)
-         (let ((result-20766 (strip-4344 when-list-20765 '(()))))
+               name-18668
+               exp-18675)))))
+     (parse-when-list-4295
+       (lambda (e-18745 when-list-18746)
+         (let ((result-18747 (strip-4310 when-list-18746 '(()))))
            (letrec*
-             ((lp-20767
-                (lambda (l-20821)
-                  (if (null? l-20821)
-                    result-20766
-                    (if (let ((t-20823 (car l-20821)))
-                          (if (eq? t-20823 'compile)
+             ((lp-18748
+                (lambda (l-18802)
+                  (if (null? l-18802)
+                    result-18747
+                    (if (let ((t-18804 (car l-18802)))
+                          (if (eq? t-18804 'compile)
                             #t
-                            (if (eq? t-20823 'load)
+                            (if (eq? t-18804 'load)
                               #t
-                              (if (eq? t-20823 'eval)
+                              (if (eq? t-18804 'eval)
                                 #t
-                                (eq? t-20823 'expand)))))
-                      (lp-20767 (cdr l-20821))
+                                (eq? t-18804 'expand)))))
+                      (lp-18748 (cdr l-18802))
                       (syntax-violation
                         'eval-when
                         "invalid situation"
-                        e-20764
-                        (car l-20821)))))))
-             (lp-20767 result-20766)))))
-     (syntax-type-4330
-       (lambda (e-20825
-                r-20826
-                w-20827
-                s-20828
-                rib-20829
-                mod-20830
-                for-car?-20831)
-         (if (symbol? e-20825)
-           (let ((n-20832 (id-var-name-4314 e-20825 w-20827)))
-             (let ((b-20833
-                     (let ((t-20842 (assq n-20832 r-20826)))
-                       (if t-20842
-                         (cdr t-20842)
-                         (if (symbol? n-20832)
-                           (let ((t-20848
-                                   (get-global-definition-hook-4258
-                                     n-20832
-                                     mod-20830)))
-                             (if t-20848 t-20848 '(global)))
+                        e-18745
+                        (car l-18802)))))))
+             (lp-18748 result-18747)))))
+     (syntax-type-4296
+       (lambda (e-18806
+                r-18807
+                w-18808
+                s-18809
+                rib-18810
+                mod-18811
+                for-car?-18812)
+         (if (symbol? e-18806)
+           (let ((n-18813 (id-var-name-4280 e-18806 w-18808)))
+             (let ((b-18814
+                     (let ((t-18823 (assq n-18813 r-18807)))
+                       (if t-18823
+                         (cdr t-18823)
+                         (if (symbol? n-18813)
+                           (let ((t-18829
+                                   (get-global-definition-hook-4224
+                                     n-18813
+                                     mod-18811)))
+                             (if t-18829 t-18829 '(global)))
                            '(displaced-lexical))))))
-               (let ((type-20834 (car b-20833)))
-                 (if (eqv? type-20834 'lexical)
+               (let ((type-18815 (car b-18814)))
+                 (if (eqv? type-18815 'lexical)
                    (values
-                     type-20834
-                     (cdr b-20833)
-                     e-20825
-                     e-20825
-                     w-20827
-                     s-20828
-                     mod-20830)
-                   (if (eqv? type-20834 'global)
+                     type-18815
+                     (cdr b-18814)
+                     e-18806
+                     e-18806
+                     w-18808
+                     s-18809
+                     mod-18811)
+                   (if (eqv? type-18815 'global)
                      (values
-                       type-20834
-                       n-20832
-                       e-20825
-                       e-20825
-                       w-20827
-                       s-20828
-                       mod-20830)
-                     (if (eqv? type-20834 'macro)
-                       (if for-car?-20831
+                       type-18815
+                       n-18813
+                       e-18806
+                       e-18806
+                       w-18808
+                       s-18809
+                       mod-18811)
+                     (if (eqv? type-18815 'macro)
+                       (if for-car?-18812
                          (values
-                           type-20834
-                           (cdr b-20833)
-                           e-20825
-                           e-20825
-                           w-20827
-                           s-20828
-                           mod-20830)
-                         (syntax-type-4330
-                           (expand-macro-4334
-                             (cdr b-20833)
-                             e-20825
-                             r-20826
-                             w-20827
-                             s-20828
-                             rib-20829
-                             mod-20830)
-                           r-20826
+                           type-18815
+                           (cdr b-18814)
+                           e-18806
+                           e-18806
+                           w-18808
+                           s-18809
+                           mod-18811)
+                         (syntax-type-4296
+                           (expand-macro-4300
+                             (cdr b-18814)
+                             e-18806
+                             r-18807
+                             w-18808
+                             s-18809
+                             rib-18810
+                             mod-18811)
+                           r-18807
                            '(())
-                           s-20828
-                           rib-20829
-                           mod-20830
+                           s-18809
+                           rib-18810
+                           mod-18811
                            #f))
                        (values
-                         type-20834
-                         (cdr b-20833)
-                         e-20825
-                         e-20825
-                         w-20827
-                         s-20828
-                         mod-20830)))))))
-           (if (pair? e-20825)
-             (let ((first-20876 (car e-20825)))
+                         type-18815
+                         (cdr b-18814)
+                         e-18806
+                         e-18806
+                         w-18808
+                         s-18809
+                         mod-18811)))))))
+           (if (pair? e-18806)
+             (let ((first-18857 (car e-18806)))
                (call-with-values
                  (lambda ()
-                   (syntax-type-4330
-                     first-20876
-                     r-20826
-                     w-20827
-                     s-20828
-                     rib-20829
-                     mod-20830
+                   (syntax-type-4296
+                     first-18857
+                     r-18807
+                     w-18808
+                     s-18809
+                     rib-18810
+                     mod-18811
                      #t))
-                 (lambda (ftype-20878
-                          fval-20879
-                          fform-20880
-                          fe-20881
-                          fw-20882
-                          fs-20883
-                          fmod-20884)
-                   (if (eqv? ftype-20878 'lexical)
+                 (lambda (ftype-18859
+                          fval-18860
+                          fform-18861
+                          fe-18862
+                          fw-18863
+                          fs-18864
+                          fmod-18865)
+                   (if (eqv? ftype-18859 'lexical)
                      (values
                        'lexical-call
-                       fval-20879
-                       e-20825
-                       e-20825
-                       w-20827
-                       s-20828
-                       mod-20830)
-                     (if (eqv? ftype-20878 'global)
+                       fval-18860
+                       e-18806
+                       e-18806
+                       w-18808
+                       s-18809
+                       mod-18811)
+                     (if (eqv? ftype-18859 'global)
                        (values
                          'global-call
                          (vector
                            'syntax-object
-                           fval-20879
-                           w-20827
-                           fmod-20884)
-                         e-20825
-                         e-20825
-                         w-20827
-                         s-20828
-                         mod-20830)
-                       (if (eqv? ftype-20878 'macro)
-                         (syntax-type-4330
-                           (expand-macro-4334
-                             fval-20879
-                             e-20825
-                             r-20826
-                             w-20827
-                             s-20828
-                             rib-20829
-                             mod-20830)
-                           r-20826
+                           fval-18860
+                           w-18808
+                           fmod-18865)
+                         e-18806
+                         e-18806
+                         w-18808
+                         s-18809
+                         mod-18811)
+                       (if (eqv? ftype-18859 'macro)
+                         (syntax-type-4296
+                           (expand-macro-4300
+                             fval-18860
+                             e-18806
+                             r-18807
+                             w-18808
+                             s-18809
+                             rib-18810
+                             mod-18811)
+                           r-18807
                            '(())
-                           s-20828
-                           rib-20829
-                           mod-20830
-                           for-car?-20831)
-                         (if (eqv? ftype-20878 'module-ref)
+                           s-18809
+                           rib-18810
+                           mod-18811
+                           for-car?-18812)
+                         (if (eqv? ftype-18859 'module-ref)
                            (call-with-values
-                             (lambda () (fval-20879 e-20825 r-20826 w-20827))
-                             (lambda (e-20918
-                                      r-20919
-                                      w-20920
-                                      s-20921
-                                      mod-20922)
-                               (syntax-type-4330
-                                 e-20918
-                                 r-20919
-                                 w-20920
-                                 s-20921
-                                 rib-20829
-                                 mod-20922
-                                 for-car?-20831)))
-                           (if (eqv? ftype-20878 'core)
+                             (lambda () (fval-18860 e-18806 r-18807 w-18808))
+                             (lambda (e-18899
+                                      r-18900
+                                      w-18901
+                                      s-18902
+                                      mod-18903)
+                               (syntax-type-4296
+                                 e-18899
+                                 r-18900
+                                 w-18901
+                                 s-18902
+                                 rib-18810
+                                 mod-18903
+                                 for-car?-18812)))
+                           (if (eqv? ftype-18859 'core)
                              (values
                                'core-form
-                               fval-20879
-                               e-20825
-                               e-20825
-                               w-20827
-                               s-20828
-                               mod-20830)
-                             (if (eqv? ftype-20878 'local-syntax)
+                               fval-18860
+                               e-18806
+                               e-18806
+                               w-18808
+                               s-18809
+                               mod-18811)
+                             (if (eqv? ftype-18859 'local-syntax)
                                (values
                                  'local-syntax-form
-                                 fval-20879
-                                 e-20825
-                                 e-20825
-                                 w-20827
-                                 s-20828
-                                 mod-20830)
-                               (if (eqv? ftype-20878 'begin)
+                                 fval-18860
+                                 e-18806
+                                 e-18806
+                                 w-18808
+                                 s-18809
+                                 mod-18811)
+                               (if (eqv? ftype-18859 'begin)
                                  (values
                                    'begin-form
                                    #f
-                                   e-20825
-                                   e-20825
-                                   w-20827
-                                   s-20828
-                                   mod-20830)
-                                 (if (eqv? ftype-20878 'eval-when)
+                                   e-18806
+                                   e-18806
+                                   w-18808
+                                   s-18809
+                                   mod-18811)
+                                 (if (eqv? ftype-18859 'eval-when)
                                    (values
                                      'eval-when-form
                                      #f
-                                     e-20825
-                                     e-20825
-                                     w-20827
-                                     s-20828
-                                     mod-20830)
-                                   (if (eqv? ftype-20878 'define)
-                                     (let ((tmp-20954
+                                     e-18806
+                                     e-18806
+                                     w-18808
+                                     s-18809
+                                     mod-18811)
+                                   (if (eqv? ftype-18859 'define)
+                                     (let ((tmp-18935
                                              ($sc-dispatch
-                                               e-20825
+                                               e-18806
                                                '(_ any any))))
-                                       (if (if tmp-20954
+                                       (if (if tmp-18935
                                              (@apply
-                                               (lambda (name-20958 val-20959)
-                                                 (if (symbol? name-20958)
+                                               (lambda (name-18939 val-18940)
+                                                 (if (symbol? name-18939)
                                                    #t
-                                                   (if (if (vector? name-20958)
+                                                   (if (if (vector? name-18939)
                                                          (if (= (vector-length
-                                                                  name-20958)
+                                                                  name-18939)
                                                                 4)
                                                            (eq? (vector-ref
-                                                                  name-20958
+                                                                  name-18939
                                                                   0)
                                                                 'syntax-object)
                                                            #f)
                                                          #f)
                                                      (symbol?
                                                        (vector-ref
-                                                         name-20958
+                                                         name-18939
                                                          1))
                                                      #f)))
-                                               tmp-20954)
+                                               tmp-18935)
                                              #f)
                                          (@apply
-                                           (lambda (name-20986 val-20987)
+                                           (lambda (name-18967 val-18968)
                                              (values
                                                'define-form
-                                               name-20986
-                                               e-20825
-                                               val-20987
-                                               w-20827
-                                               s-20828
-                                               mod-20830))
-                                           tmp-20954)
-                                         (let ((tmp-20988
+                                               name-18967
+                                               e-18806
+                                               val-18968
+                                               w-18808
+                                               s-18809
+                                               mod-18811))
+                                           tmp-18935)
+                                         (let ((tmp-18969
                                                  ($sc-dispatch
-                                                   e-20825
+                                                   e-18806
                                                    '(_ (any . any)
                                                        any
                                                        .
                                                        each-any))))
-                                           (if (if tmp-20988
+                                           (if (if tmp-18969
                                                  (@apply
-                                                   (lambda (name-20992
-                                                            args-20993
-                                                            e1-20994
-                                                            e2-20995)
+                                                   (lambda (name-18973
+                                                            args-18974
+                                                            e1-18975
+                                                            e2-18976)
                                                      (if (if (symbol?
-                                                               name-20992)
+                                                               name-18973)
                                                            #t
                                                            (if (if (vector?
-                                                                     
name-20992)
+                                                                     
name-18973)
                                                                  (if (= 
(vector-length
-                                                                          
name-20992)
+                                                                          
name-18973)
                                                                         4)
                                                                    (eq? 
(vector-ref
-                                                                          
name-20992
+                                                                          
name-18973
                                                                           0)
                                                                         
'syntax-object)
                                                                    #f)
                                                                  #f)
                                                              (symbol?
                                                                (vector-ref
-                                                                 name-20992
+                                                                 name-18973
                                                                  1))
                                                              #f))
-                                                       (valid-bound-ids?-4321
+                                                       (valid-bound-ids?-4287
                                                          (letrec*
-                                                           ((lvl-21144
-                                                              (lambda 
(vars-21146
-                                                                       ls-21147
-                                                                       w-21148)
-                                                                (if (pair? 
vars-21146)
-                                                                  (lvl-21144
-                                                                    (cdr 
vars-21146)
-                                                                    (cons 
(wrap-4324
-                                                                            
(car vars-21146)
-                                                                            
w-21148
+                                                           ((lvl-19125
+                                                              (lambda 
(vars-19127
+                                                                       ls-19128
+                                                                       w-19129)
+                                                                (if (pair? 
vars-19127)
+                                                                  (lvl-19125
+                                                                    (cdr 
vars-19127)
+                                                                    (cons 
(wrap-4290
+                                                                            
(car vars-19127)
+                                                                            
w-19129
                                                                             #f)
-                                                                          
ls-21147)
-                                                                    w-21148)
+                                                                          
ls-19128)
+                                                                    w-19129)
                                                                   (if (if 
(symbol?
-                                                                            
vars-21146)
+                                                                            
vars-19127)
                                                                         #t
                                                                         (if 
(if (vector?
-                                                                               
   vars-21146)
+                                                                               
   vars-19127)
                                                                               
(if (= (vector-length
-                                                                               
        vars-21146)
+                                                                               
        vars-19127)
                                                                                
      4)
                                                                                
 (eq? (vector-ref
-                                                                               
        vars-21146
+                                                                               
        vars-19127
                                                                                
        0)
                                                                                
      'syntax-object)
                                                                                
 #f)
                                                                               
#f)
                                                                           
(symbol?
                                                                             
(vector-ref
-                                                                              
vars-21146
+                                                                              
vars-19127
                                                                               
1))
                                                                           #f))
-                                                                    (cons 
(wrap-4324
-                                                                            
vars-21146
-                                                                            
w-21148
+                                                                    (cons 
(wrap-4290
+                                                                            
vars-19127
+                                                                            
w-19129
                                                                             #f)
-                                                                          
ls-21147)
-                                                                    (if (null? 
vars-21146)
-                                                                      ls-21147
+                                                                          
ls-19128)
+                                                                    (if (null? 
vars-19127)
+                                                                      ls-19128
                                                                       (if (if 
(vector?
-                                                                               
 vars-21146)
+                                                                               
 vars-19127)
                                                                             
(if (= (vector-length
-                                                                               
      vars-21146)
+                                                                               
      vars-19127)
                                                                                
    4)
                                                                               
(eq? (vector-ref
-                                                                               
      vars-21146
+                                                                               
      vars-19127
                                                                                
      0)
                                                                                
    'syntax-object)
                                                                               
#f)
                                                                             #f)
-                                                                        
(lvl-21144
+                                                                        
(lvl-19125
                                                                           
(vector-ref
-                                                                            
vars-21146
+                                                                            
vars-19127
                                                                             1)
-                                                                          
ls-21147
-                                                                          
(join-wraps-4311
-                                                                            
w-21148
+                                                                          
ls-19128
+                                                                          
(join-wraps-4277
+                                                                            
w-19129
                                                                             
(vector-ref
-                                                                              
vars-21146
+                                                                              
vars-19127
                                                                               
2)))
-                                                                        (cons 
vars-21146
-                                                                              
ls-21147))))))))
-                                                           (lvl-21144
-                                                             args-20993
+                                                                        (cons 
vars-19127
+                                                                              
ls-19128))))))))
+                                                           (lvl-19125
+                                                             args-18974
                                                              '()
                                                              '(()))))
                                                        #f))
-                                                   tmp-20988)
+                                                   tmp-18969)
                                                  #f)
                                              (@apply
-                                               (lambda (name-21192
-                                                        args-21193
-                                                        e1-21194
-                                                        e2-21195)
+                                               (lambda (name-19173
+                                                        args-19174
+                                                        e1-19175
+                                                        e2-19176)
                                                  (values
                                                    'define-form
-                                                   (wrap-4324
-                                                     name-21192
-                                                     w-20827
-                                                     mod-20830)
-                                                   (wrap-4324
-                                                     e-20825
-                                                     w-20827
-                                                     mod-20830)
-                                                   (let ((e-21203
+                                                   (wrap-4290
+                                                     name-19173
+                                                     w-18808
+                                                     mod-18811)
+                                                   (wrap-4290
+                                                     e-18806
+                                                     w-18808
+                                                     mod-18811)
+                                                   (let ((e-19184
                                                            (cons 
'#(syntax-object
                                                                     lambda
                                                                     ((top)
@@ -2194,65 +2472,65 @@
                                                                         
"l-*-45")))
                                                                     (hygiene
                                                                       guile))
-                                                                 (wrap-4324
-                                                                   (cons 
args-21193
-                                                                         (cons 
e1-21194
-                                                                               
e2-21195))
-                                                                   w-20827
-                                                                   
mod-20830))))
+                                                                 (wrap-4290
+                                                                   (cons 
args-19174
+                                                                         (cons 
e1-19175
+                                                                               
e2-19176))
+                                                                   w-18808
+                                                                   
mod-18811))))
                                                      (begin
-                                                       (if (if s-20828
+                                                       (if (if s-18809
                                                              
(supports-source-properties?
-                                                               e-21203)
+                                                               e-19184)
                                                              #f)
                                                          
(set-source-properties!
-                                                           e-21203
-                                                           s-20828))
-                                                       e-21203))
+                                                           e-19184
+                                                           s-18809))
+                                                       e-19184))
                                                    '(())
-                                                   s-20828
-                                                   mod-20830))
-                                               tmp-20988)
-                                             (let ((tmp-21210
+                                                   s-18809
+                                                   mod-18811))
+                                               tmp-18969)
+                                             (let ((tmp-19191
                                                      ($sc-dispatch
-                                                       e-20825
+                                                       e-18806
                                                        '(_ any))))
-                                               (if (if tmp-21210
+                                               (if (if tmp-19191
                                                      (@apply
-                                                       (lambda (name-21214)
+                                                       (lambda (name-19195)
                                                          (if (symbol?
-                                                               name-21214)
+                                                               name-19195)
                                                            #t
                                                            (if (if (vector?
-                                                                     
name-21214)
+                                                                     
name-19195)
                                                                  (if (= 
(vector-length
-                                                                          
name-21214)
+                                                                          
name-19195)
                                                                         4)
                                                                    (eq? 
(vector-ref
-                                                                          
name-21214
+                                                                          
name-19195
                                                                           0)
                                                                         
'syntax-object)
                                                                    #f)
                                                                  #f)
                                                              (symbol?
                                                                (vector-ref
-                                                                 name-21214
+                                                                 name-19195
                                                                  1))
                                                              #f)))
-                                                       tmp-21210)
+                                                       tmp-19191)
                                                      #f)
                                                  (@apply
-                                                   (lambda (name-21241)
+                                                   (lambda (name-19222)
                                                      (values
                                                        'define-form
-                                                       (wrap-4324
-                                                         name-21241
-                                                         w-20827
-                                                         mod-20830)
-                                                       (wrap-4324
-                                                         e-20825
-                                                         w-20827
-                                                         mod-20830)
+                                                       (wrap-4290
+                                                         name-19222
+                                                         w-18808
+                                                         mod-18811)
+                                                       (wrap-4290
+                                                         e-18806
+                                                         w-18808
+                                                         mod-18811)
                                                        '(#(syntax-object
                                                            if
                                                            ((top)
@@ -3745,300 +4023,437 @@
                                                                "l-*-45")))
                                                            (hygiene guile)))
                                                        '(())
-                                                       s-20828
-                                                       mod-20830))
-                                                   tmp-21210)
+                                                       s-18809
+                                                       mod-18811))
+                                                   tmp-19191)
                                                  (syntax-violation
                                                    #f
                                                    "source expression failed 
to match any pattern"
-                                                   e-20825)))))))
-                                     (if (eqv? ftype-20878 'define-syntax)
-                                       (let ((tmp-21265
+                                                   e-18806)))))))
+                                     (if (eqv? ftype-18859 'define-syntax)
+                                       (let ((tmp-19246
                                                ($sc-dispatch
-                                                 e-20825
+                                                 e-18806
                                                  '(_ any any))))
-                                         (if (if tmp-21265
+                                         (if (if tmp-19246
                                                (@apply
-                                                 (lambda (name-21269 val-21270)
-                                                   (if (symbol? name-21269)
+                                                 (lambda (name-19250 val-19251)
+                                                   (if (symbol? name-19250)
                                                      #t
                                                      (if (if (vector?
-                                                               name-21269)
+                                                               name-19250)
                                                            (if (= 
(vector-length
-                                                                    name-21269)
+                                                                    name-19250)
                                                                   4)
                                                              (eq? (vector-ref
-                                                                    name-21269
+                                                                    name-19250
                                                                     0)
                                                                   
'syntax-object)
                                                              #f)
                                                            #f)
                                                        (symbol?
                                                          (vector-ref
-                                                           name-21269
+                                                           name-19250
                                                            1))
                                                        #f)))
-                                                 tmp-21265)
+                                                 tmp-19246)
                                                #f)
                                            (@apply
-                                             (lambda (name-21297 val-21298)
+                                             (lambda (name-19278 val-19279)
                                                (values
                                                  'define-syntax-form
-                                                 name-21297
-                                                 e-20825
-                                                 val-21298
-                                                 w-20827
-                                                 s-20828
-                                                 mod-20830))
-                                             tmp-21265)
+                                                 name-19278
+                                                 e-18806
+                                                 val-19279
+                                                 w-18808
+                                                 s-18809
+                                                 mod-18811))
+                                             tmp-19246)
                                            (syntax-violation
                                              #f
                                              "source expression failed to 
match any pattern"
-                                             e-20825)))
-                                       (if (eqv? ftype-20878
+                                             e-18806)))
+                                       (if (eqv? ftype-18859
                                                  'define-syntax-parameter)
-                                         (let ((tmp-21312
+                                         (let ((tmp-19293
                                                  ($sc-dispatch
-                                                   e-20825
+                                                   e-18806
                                                    '(_ any any))))
-                                           (if (if tmp-21312
+                                           (if (if tmp-19293
                                                  (@apply
-                                                   (lambda (name-21316
-                                                            val-21317)
-                                                     (if (symbol? name-21316)
+                                                   (lambda (name-19297
+                                                            val-19298)
+                                                     (if (symbol? name-19297)
                                                        #t
                                                        (if (if (vector?
-                                                                 name-21316)
+                                                                 name-19297)
                                                              (if (= 
(vector-length
-                                                                      
name-21316)
+                                                                      
name-19297)
                                                                     4)
                                                                (eq? (vector-ref
-                                                                      
name-21316
+                                                                      
name-19297
                                                                       0)
                                                                     
'syntax-object)
                                                                #f)
                                                              #f)
                                                          (symbol?
                                                            (vector-ref
-                                                             name-21316
+                                                             name-19297
                                                              1))
                                                          #f)))
-                                                   tmp-21312)
+                                                   tmp-19293)
                                                  #f)
                                              (@apply
-                                               (lambda (name-21344 val-21345)
+                                               (lambda (name-19325 val-19326)
                                                  (values
                                                    
'define-syntax-parameter-form
-                                                   name-21344
-                                                   e-20825
-                                                   val-21345
-                                                   w-20827
-                                                   s-20828
-                                                   mod-20830))
-                                               tmp-21312)
+                                                   name-19325
+                                                   e-18806
+                                                   val-19326
+                                                   w-18808
+                                                   s-18809
+                                                   mod-18811))
+                                               tmp-19293)
                                              (syntax-violation
                                                #f
                                                "source expression failed to 
match any pattern"
-                                               e-20825)))
+                                               e-18806)))
                                          (values
                                            'call
                                            #f
-                                           e-20825
-                                           e-20825
-                                           w-20827
-                                           s-20828
-                                           mod-20830)))))))))))))))
-             (if (if (vector? e-20825)
-                   (if (= (vector-length e-20825) 4)
-                     (eq? (vector-ref e-20825 0) 'syntax-object)
+                                           e-18806
+                                           e-18806
+                                           w-18808
+                                           s-18809
+                                           mod-18811)))))))))))))))
+             (if (if (vector? e-18806)
+                   (if (= (vector-length e-18806) 4)
+                     (eq? (vector-ref e-18806 0) 'syntax-object)
                      #f)
                    #f)
-               (syntax-type-4330
-                 (vector-ref e-20825 1)
-                 r-20826
-                 (join-wraps-4311 w-20827 (vector-ref e-20825 2))
-                 (let ((t-21372 (source-annotation-4288 e-20825)))
-                   (if t-21372 t-21372 s-20828))
-                 rib-20829
-                 (let ((t-21607 (vector-ref e-20825 3)))
-                   (if t-21607 t-21607 mod-20830))
-                 for-car?-20831)
-               (if (self-evaluating? e-20825)
+               (syntax-type-4296
+                 (vector-ref e-18806 1)
+                 r-18807
+                 (join-wraps-4277 w-18808 (vector-ref e-18806 2))
+                 (let ((t-19353
+                         (let ((props-19385
+                                 (source-properties
+                                   (if (if (vector? e-18806)
+                                         (if (= (vector-length e-18806) 4)
+                                           (eq? (vector-ref e-18806 0)
+                                                'syntax-object)
+                                           #f)
+                                         #f)
+                                     (vector-ref e-18806 1)
+                                     e-18806))))
+                           (if (pair? props-19385) props-19385 #f))))
+                   (if t-19353 t-19353 s-18809))
+                 rib-18810
+                 (let ((t-19408 (vector-ref e-18806 3)))
+                   (if t-19408 t-19408 mod-18811))
+                 for-car?-18812)
+               (if (self-evaluating? e-18806)
                  (values
                    'constant
                    #f
-                   e-20825
-                   e-20825
-                   w-20827
-                   s-20828
-                   mod-20830)
+                   e-18806
+                   e-18806
+                   w-18808
+                   s-18809
+                   mod-18811)
                  (values
                    'other
                    #f
-                   e-20825
-                   e-20825
-                   w-20827
-                   s-20828
-                   mod-20830)))))))
-     (expand-4331
-       (lambda (e-21616 r-21617 w-21618 mod-21619)
+                   e-18806
+                   e-18806
+                   w-18808
+                   s-18809
+                   mod-18811)))))))
+     (expand-4297
+       (lambda (e-19417 r-19418 w-19419 mod-19420)
          (call-with-values
            (lambda ()
-             (syntax-type-4330
-               e-21616
-               r-21617
-               w-21618
-               (source-annotation-4288 e-21616)
+             (syntax-type-4296
+               e-19417
+               r-19418
+               w-19419
+               (let ((props-19427
+                       (source-properties
+                         (if (if (vector? e-19417)
+                               (if (= (vector-length e-19417) 4)
+                                 (eq? (vector-ref e-19417 0) 'syntax-object)
+                                 #f)
+                               #f)
+                           (vector-ref e-19417 1)
+                           e-19417))))
+                 (if (pair? props-19427) props-19427 #f))
                #f
-               mod-21619
+               mod-19420
                #f))
-           (lambda (type-21774
-                    value-21775
-                    form-21776
-                    e-21777
-                    w-21778
-                    s-21779
-                    mod-21780)
-             (expand-expr-4332
-               type-21774
-               value-21775
-               form-21776
-               e-21777
-               r-21617
-               w-21778
-               s-21779
-               mod-21780)))))
-     (expand-expr-4332
-       (lambda (type-21783
-                value-21784
-                form-21785
-                e-21786
-                r-21787
-                w-21788
-                s-21789
-                mod-21790)
-         (if (eqv? type-21783 'lexical)
+           (lambda (type-19450
+                    value-19451
+                    form-19452
+                    e-19453
+                    w-19454
+                    s-19455
+                    mod-19456)
+             (expand-expr-4298
+               type-19450
+               value-19451
+               form-19452
+               e-19453
+               r-19418
+               w-19454
+               s-19455
+               mod-19456)))))
+     (expand-expr-4298
+       (lambda (type-19459
+                value-19460
+                form-19461
+                e-19462
+                r-19463
+                w-19464
+                s-19465
+                mod-19466)
+         (if (eqv? type-19459 'lexical)
            (make-struct/no-tail
              (vector-ref %expanded-vtables 3)
-             s-21789
-             e-21786
-             value-21784)
-           (if (if (eqv? type-21783 'core)
+             s-19465
+             e-19462
+             value-19460)
+           (if (if (eqv? type-19459 'core)
                  #t
-                 (eqv? type-21783 'core-form))
-             (value-21784
-               e-21786
-               r-21787
-               w-21788
-               s-21789
-               mod-21790)
-             (if (eqv? type-21783 'module-ref)
+                 (eqv? type-19459 'core-form))
+             (value-19460
+               e-19462
+               r-19463
+               w-19464
+               s-19465
+               mod-19466)
+             (if (eqv? type-19459 'module-ref)
                (call-with-values
-                 (lambda () (value-21784 e-21786 r-21787 w-21788))
-                 (lambda (e-21826 r-21827 w-21828 s-21829 mod-21830)
-                   (expand-4331 e-21826 r-21827 w-21828 mod-21830)))
-               (if (eqv? type-21783 'lexical-call)
-                 (expand-application-4333
-                   (let ((id-21908 (car e-21786)))
-                     (build-lexical-reference-4265
-                       'fun
-                       (source-annotation-4288 id-21908)
-                       (if (if (vector? id-21908)
-                             (if (= (vector-length id-21908) 4)
-                               (eq? (vector-ref id-21908 0) 'syntax-object)
-                               #f)
-                             #f)
-                         (syntax->datum id-21908)
-                         id-21908)
-                       value-21784))
-                   e-21786
-                   r-21787
-                   w-21788
-                   s-21789
-                   mod-21790)
-                 (if (eqv? type-21783 'global-call)
-                   (expand-application-4333
-                     (build-global-reference-4268
-                       (source-annotation-4288 (car e-21786))
-                       (if (if (vector? value-21784)
-                             (if (= (vector-length value-21784) 4)
-                               (eq? (vector-ref value-21784 0) 'syntax-object)
-                               #f)
-                             #f)
-                         (vector-ref value-21784 1)
-                         value-21784)
-                       (if (if (vector? value-21784)
-                             (if (= (vector-length value-21784) 4)
-                               (eq? (vector-ref value-21784 0) 'syntax-object)
-                               #f)
-                             #f)
-                         (vector-ref value-21784 3)
-                         mod-21790))
-                     e-21786
-                     r-21787
-                     w-21788
-                     s-21789
-                     mod-21790)
-                   (if (eqv? type-21783 'constant)
-                     (let ((exp-22251
-                             (strip-4344
-                               (wrap-4324
+                 (lambda () (value-19460 e-19462 r-19463 w-19464))
+                 (lambda (e-19502 r-19503 w-19504 s-19505 mod-19506)
+                   (call-with-values
+                     (lambda ()
+                       (syntax-type-4296
+                         e-19502
+                         r-19503
+                         w-19504
+                         (let ((props-19522
+                                 (source-properties
+                                   (if (if (vector? e-19502)
+                                         (if (= (vector-length e-19502) 4)
+                                           (eq? (vector-ref e-19502 0)
+                                                'syntax-object)
+                                           #f)
+                                         #f)
+                                     (vector-ref e-19502 1)
+                                     e-19502))))
+                           (if (pair? props-19522) props-19522 #f))
+                         #f
+                         mod-19506
+                         #f))
+                     (lambda (type-19555
+                              value-19556
+                              form-19557
+                              e-19558
+                              w-19559
+                              s-19560
+                              mod-19561)
+                       (expand-expr-4298
+                         type-19555
+                         value-19556
+                         form-19557
+                         e-19558
+                         r-19503
+                         w-19559
+                         s-19560
+                         mod-19561)))))
+               (if (eqv? type-19459 'lexical-call)
+                 (expand-application-4299
+                   (let ((id-19572 (car e-19462)))
+                     (let ((source-19577
+                             (let ((props-19587
+                                     (source-properties
+                                       (if (if (vector? id-19572)
+                                             (if (= (vector-length id-19572) 4)
+                                               (eq? (vector-ref id-19572 0)
+                                                    'syntax-object)
+                                               #f)
+                                             #f)
+                                         (vector-ref id-19572 1)
+                                         id-19572))))
+                               (if (pair? props-19587) props-19587 #f)))
+                           (name-19578
+                             (if (if (vector? id-19572)
+                                   (if (= (vector-length id-19572) 4)
+                                     (eq? (vector-ref id-19572 0)
+                                          'syntax-object)
+                                     #f)
+                                   #f)
+                               (syntax->datum id-19572)
+                               id-19572)))
+                       (make-struct/no-tail
+                         (vector-ref %expanded-vtables 3)
+                         source-19577
+                         name-19578
+                         value-19460)))
+                   e-19462
+                   r-19463
+                   w-19464
+                   s-19465
+                   mod-19466)
+                 (if (eqv? type-19459 'global-call)
+                   (expand-application-4299
+                     (let ((source-19630
+                             (let ((x-19669 (car e-19462)))
+                               (let ((props-19670
+                                       (source-properties
+                                         (if (if (vector? x-19669)
+                                               (if (= (vector-length x-19669)
+                                                      4)
+                                                 (eq? (vector-ref x-19669 0)
+                                                      'syntax-object)
+                                                 #f)
+                                               #f)
+                                           (vector-ref x-19669 1)
+                                           x-19669))))
+                                 (if (pair? props-19670) props-19670 #f))))
+                           (var-19631
+                             (if (if (vector? value-19460)
+                                   (if (= (vector-length value-19460) 4)
+                                     (eq? (vector-ref value-19460 0)
+                                          'syntax-object)
+                                     #f)
+                                   #f)
+                               (vector-ref value-19460 1)
+                               value-19460))
+                           (mod-19632
+                             (if (if (vector? value-19460)
+                                   (if (= (vector-length value-19460) 4)
+                                     (eq? (vector-ref value-19460 0)
+                                          'syntax-object)
+                                     #f)
+                                   #f)
+                               (vector-ref value-19460 3)
+                               mod-19466)))
+                       (analyze-variable-4233
+                         mod-19632
+                         var-19631
+                         (lambda (mod-19658 var-19659 public?-19660)
+                           (make-struct/no-tail
+                             (vector-ref %expanded-vtables 5)
+                             source-19630
+                             mod-19658
+                             var-19659
+                             public?-19660))
+                         (lambda (var-19683)
+                           (make-struct/no-tail
+                             (vector-ref %expanded-vtables 7)
+                             source-19630
+                             var-19683))))
+                     e-19462
+                     r-19463
+                     w-19464
+                     s-19465
+                     mod-19466)
+                   (if (eqv? type-19459 'constant)
+                     (let ((exp-19698
+                             (strip-4310
+                               (wrap-4290
                                  (begin
-                                   (if (if s-21789
-                                         (supports-source-properties? e-21786)
+                                   (if (if s-19465
+                                         (supports-source-properties? e-19462)
                                          #f)
-                                     (set-source-properties! e-21786 s-21789))
-                                   e-21786)
-                                 w-21788
-                                 mod-21790)
+                                     (set-source-properties! e-19462 s-19465))
+                                   e-19462)
+                                 w-19464
+                                 mod-19466)
                                '(()))))
                        (make-struct/no-tail
                          (vector-ref %expanded-vtables 1)
-                         s-21789
-                         exp-22251))
-                     (if (eqv? type-21783 'global)
-                       (analyze-variable-4267
-                         mod-21790
-                         value-21784
-                         (lambda (mod-22290 var-22291 public?-22292)
+                         s-19465
+                         exp-19698))
+                     (if (eqv? type-19459 'global)
+                       (analyze-variable-4233
+                         mod-19466
+                         value-19460
+                         (lambda (mod-19737 var-19738 public?-19739)
                            (make-struct/no-tail
                              (vector-ref %expanded-vtables 5)
-                             s-21789
-                             mod-22290
-                             var-22291
-                             public?-22292))
-                         (lambda (var-22301)
+                             s-19465
+                             mod-19737
+                             var-19738
+                             public?-19739))
+                         (lambda (var-19748)
                            (make-struct/no-tail
                              (vector-ref %expanded-vtables 7)
-                             s-21789
-                             var-22301)))
-                       (if (eqv? type-21783 'call)
-                         (expand-application-4333
-                           (expand-4331
-                             (car e-21786)
-                             r-21787
-                             w-21788
-                             mod-21790)
-                           e-21786
-                           r-21787
-                           w-21788
-                           s-21789
-                           mod-21790)
-                         (if (eqv? type-21783 'begin-form)
-                           (let ((tmp-22382
-                                   ($sc-dispatch e-21786 '(_ any . each-any))))
-                             (if tmp-22382
+                             s-19465
+                             var-19748)))
+                       (if (eqv? type-19459 'call)
+                         (expand-application-4299
+                           (let ((e-19766 (car e-19462)))
+                             (call-with-values
+                               (lambda ()
+                                 (syntax-type-4296
+                                   e-19766
+                                   r-19463
+                                   w-19464
+                                   (let ((props-19776
+                                           (source-properties
+                                             (if (if (vector? e-19766)
+                                                   (if (= (vector-length
+                                                            e-19766)
+                                                          4)
+                                                     (eq? (vector-ref
+                                                            e-19766
+                                                            0)
+                                                          'syntax-object)
+                                                     #f)
+                                                   #f)
+                                               (vector-ref e-19766 1)
+                                               e-19766))))
+                                     (if (pair? props-19776) props-19776 #f))
+                                   #f
+                                   mod-19466
+                                   #f))
+                               (lambda (type-19799
+                                        value-19800
+                                        form-19801
+                                        e-19802
+                                        w-19803
+                                        s-19804
+                                        mod-19805)
+                                 (expand-expr-4298
+                                   type-19799
+                                   value-19800
+                                   form-19801
+                                   e-19802
+                                   r-19463
+                                   w-19803
+                                   s-19804
+                                   mod-19805))))
+                           e-19462
+                           r-19463
+                           w-19464
+                           s-19465
+                           mod-19466)
+                         (if (eqv? type-19459 'begin-form)
+                           (let ((tmp-19815
+                                   ($sc-dispatch e-19462 '(_ any . each-any))))
+                             (if tmp-19815
                                (@apply
-                                 (lambda (e1-22386 e2-22387)
-                                   (expand-sequence-4326
-                                     (cons e1-22386 e2-22387)
-                                     r-21787
-                                     w-21788
-                                     s-21789
-                                     mod-21790))
-                                 tmp-22382)
-                               (let ((tmp-22474 ($sc-dispatch e-21786 '(_))))
-                                 (if tmp-22474
+                                 (lambda (e1-19819 e2-19820)
+                                   (expand-sequence-4292
+                                     (cons e1-19819 e2-19820)
+                                     r-19463
+                                     w-19464
+                                     s-19465
+                                     mod-19466))
+                                 tmp-19815)
+                               (let ((tmp-19947 ($sc-dispatch e-19462 '(_))))
+                                 (if tmp-19947
                                    (@apply
                                      (lambda ()
                                        (if (include-deprecated-features)
@@ -4051,831 +4466,1047 @@
                                          (syntax-violation
                                            #f
                                            "sequence of zero expressions"
-                                           (wrap-4324
+                                           (wrap-4290
                                              (begin
-                                               (if (if s-21789
+                                               (if (if s-19465
                                                      
(supports-source-properties?
-                                                       e-21786)
+                                                       e-19462)
                                                      #f)
                                                  (set-source-properties!
-                                                   e-21786
-                                                   s-21789))
-                                               e-21786)
-                                             w-21788
-                                             mod-21790))))
-                                     tmp-22474)
+                                                   e-19462
+                                                   s-19465))
+                                               e-19462)
+                                             w-19464
+                                             mod-19466))))
+                                     tmp-19947)
                                    (syntax-violation
                                      #f
                                      "source expression failed to match any 
pattern"
-                                     e-21786)))))
-                           (if (eqv? type-21783 'local-syntax-form)
-                             (expand-local-syntax-4336
-                               value-21784
-                               e-21786
-                               r-21787
-                               w-21788
-                               s-21789
-                               mod-21790
-                               expand-sequence-4326)
-                             (if (eqv? type-21783 'eval-when-form)
-                               (let ((tmp-22591
+                                     e-19462)))))
+                           (if (eqv? type-19459 'local-syntax-form)
+                             (expand-local-syntax-4302
+                               value-19460
+                               e-19462
+                               r-19463
+                               w-19464
+                               s-19465
+                               mod-19466
+                               expand-sequence-4292)
+                             (if (eqv? type-19459 'eval-when-form)
+                               (let ((tmp-20059
                                        ($sc-dispatch
-                                         e-21786
+                                         e-19462
                                          '(_ each-any any . each-any))))
-                                 (if tmp-22591
+                                 (if tmp-20059
                                    (@apply
-                                     (lambda (x-22595 e1-22596 e2-22597)
-                                       (let ((when-list-22598
-                                               (parse-when-list-4329
-                                                 e-21786
-                                                 x-22595)))
-                                         (if (memq 'eval when-list-22598)
-                                           (expand-sequence-4326
-                                             (cons e1-22596 e2-22597)
-                                             r-21787
-                                             w-21788
-                                             s-21789
-                                             mod-21790)
+                                     (lambda (x-20063 e1-20064 e2-20065)
+                                       (let ((when-list-20066
+                                               (parse-when-list-4295
+                                                 e-19462
+                                                 x-20063)))
+                                         (if (memq 'eval when-list-20066)
+                                           (expand-sequence-4292
+                                             (cons e1-20064 e2-20065)
+                                             r-19463
+                                             w-19464
+                                             s-19465
+                                             mod-19466)
                                            (make-struct/no-tail
                                              (vector-ref %expanded-vtables 0)
                                              #f))))
-                                     tmp-22591)
+                                     tmp-20059)
                                    (syntax-violation
                                      #f
                                      "source expression failed to match any 
pattern"
-                                     e-21786)))
-                               (if (if (eqv? type-21783 'define-form)
+                                     e-19462)))
+                               (if (if (eqv? type-19459 'define-form)
                                      #t
-                                     (if (eqv? type-21783 'define-syntax-form)
+                                     (if (eqv? type-19459 'define-syntax-form)
                                        #t
-                                       (eqv? type-21783
+                                       (eqv? type-19459
                                              'define-syntax-parameter-form)))
                                  (syntax-violation
                                    #f
                                    "definition in expression context, where 
definitions are not allowed,"
-                                   (wrap-4324
+                                   (wrap-4290
                                      (begin
-                                       (if (if s-21789
+                                       (if (if s-19465
                                              (supports-source-properties?
-                                               form-21785)
+                                               form-19461)
                                              #f)
                                          (set-source-properties!
-                                           form-21785
-                                           s-21789))
-                                       form-21785)
-                                     w-21788
-                                     mod-21790))
-                                 (if (eqv? type-21783 'syntax)
+                                           form-19461
+                                           s-19465))
+                                       form-19461)
+                                     w-19464
+                                     mod-19466))
+                                 (if (eqv? type-19459 'syntax)
                                    (syntax-violation
                                      #f
                                      "reference to pattern variable outside 
syntax form"
-                                     (wrap-4324
+                                     (wrap-4290
                                        (begin
-                                         (if (if s-21789
+                                         (if (if s-19465
                                                (supports-source-properties?
-                                                 e-21786)
+                                                 e-19462)
                                                #f)
                                            (set-source-properties!
-                                             e-21786
-                                             s-21789))
-                                         e-21786)
-                                       w-21788
-                                       mod-21790))
-                                   (if (eqv? type-21783 'displaced-lexical)
+                                             e-19462
+                                             s-19465))
+                                         e-19462)
+                                       w-19464
+                                       mod-19466))
+                                   (if (eqv? type-19459 'displaced-lexical)
                                      (syntax-violation
                                        #f
                                        "reference to identifier outside its 
scope"
-                                       (wrap-4324
+                                       (wrap-4290
                                          (begin
-                                           (if (if s-21789
+                                           (if (if s-19465
                                                  (supports-source-properties?
-                                                   e-21786)
+                                                   e-19462)
                                                  #f)
                                              (set-source-properties!
-                                               e-21786
-                                               s-21789))
-                                           e-21786)
-                                         w-21788
-                                         mod-21790))
+                                               e-19462
+                                               s-19465))
+                                           e-19462)
+                                         w-19464
+                                         mod-19466))
                                      (syntax-violation
                                        #f
                                        "unexpected syntax"
-                                       (wrap-4324
+                                       (wrap-4290
                                          (begin
-                                           (if (if s-21789
+                                           (if (if s-19465
                                                  (supports-source-properties?
-                                                   e-21786)
+                                                   e-19462)
                                                  #f)
                                              (set-source-properties!
-                                               e-21786
-                                               s-21789))
-                                           e-21786)
-                                         w-21788
-                                         mod-21790))))))))))))))))))
-     (expand-application-4333
-       (lambda (x-22867
-                e-22868
-                r-22869
-                w-22870
-                s-22871
-                mod-22872)
-         (let ((tmp-22874
-                 ($sc-dispatch e-22868 '(any . each-any))))
-           (if tmp-22874
+                                               e-19462
+                                               s-19465))
+                                           e-19462)
+                                         w-19464
+                                         mod-19466))))))))))))))))))
+     (expand-application-4299
+       (lambda (x-20375
+                e-20376
+                r-20377
+                w-20378
+                s-20379
+                mod-20380)
+         (let ((tmp-20382
+                 ($sc-dispatch e-20376 '(any . each-any))))
+           (if tmp-20382
              (@apply
-               (lambda (e0-22878 e1-22879)
-                 (build-application-4262
-                   s-22871
-                   x-22867
-                   (map (lambda (e-22959)
-                          (expand-4331 e-22959 r-22869 w-22870 mod-22872))
-                        e1-22879)))
-               tmp-22874)
+               (lambda (e0-20386 e1-20387)
+                 (let ((arg-exps-20393
+                         (map (lambda (e-20398)
+                                (call-with-values
+                                  (lambda ()
+                                    (syntax-type-4296
+                                      e-20398
+                                      r-20377
+                                      w-20378
+                                      (let ((props-20413
+                                              (source-properties
+                                                (if (if (vector? e-20398)
+                                                      (if (= (vector-length
+                                                               e-20398)
+                                                             4)
+                                                        (eq? (vector-ref
+                                                               e-20398
+                                                               0)
+                                                             'syntax-object)
+                                                        #f)
+                                                      #f)
+                                                  (vector-ref e-20398 1)
+                                                  e-20398))))
+                                        (if (pair? props-20413)
+                                          props-20413
+                                          #f))
+                                      #f
+                                      mod-20380
+                                      #f))
+                                  (lambda (type-20446
+                                           value-20447
+                                           form-20448
+                                           e-20449
+                                           w-20450
+                                           s-20451
+                                           mod-20452)
+                                    (expand-expr-4298
+                                      type-20446
+                                      value-20447
+                                      form-20448
+                                      e-20449
+                                      r-20377
+                                      w-20450
+                                      s-20451
+                                      mod-20452))))
+                              e1-20387)))
+                   (make-struct/no-tail
+                     (vector-ref %expanded-vtables 11)
+                     s-20379
+                     x-20375
+                     arg-exps-20393)))
+               tmp-20382)
              (syntax-violation
                #f
                "source expression failed to match any pattern"
-               e-22868)))))
-     (expand-macro-4334
-       (lambda (p-23035
-                e-23036
-                r-23037
-                w-23038
-                s-23039
-                rib-23040
-                mod-23041)
+               e-20376)))))
+     (expand-macro-4300
+       (lambda (p-20462
+                e-20463
+                r-20464
+                w-20465
+                s-20466
+                rib-20467
+                mod-20468)
          (letrec*
-           ((rebuild-macro-output-23042
-              (lambda (x-23075 m-23076)
-                (if (pair? x-23075)
-                  (let ((e-23080
-                          (cons (rebuild-macro-output-23042
-                                  (car x-23075)
-                                  m-23076)
-                                (rebuild-macro-output-23042
-                                  (cdr x-23075)
-                                  m-23076))))
+           ((rebuild-macro-output-20469
+              (lambda (x-20502 m-20503)
+                (if (pair? x-20502)
+                  (let ((e-20507
+                          (cons (rebuild-macro-output-20469
+                                  (car x-20502)
+                                  m-20503)
+                                (rebuild-macro-output-20469
+                                  (cdr x-20502)
+                                  m-20503))))
                     (begin
-                      (if (if s-23039
-                            (supports-source-properties? e-23080)
+                      (if (if s-20466
+                            (supports-source-properties? e-20507)
                             #f)
-                        (set-source-properties! e-23080 s-23039))
-                      e-23080))
-                  (if (if (vector? x-23075)
-                        (if (= (vector-length x-23075) 4)
-                          (eq? (vector-ref x-23075 0) 'syntax-object)
+                        (set-source-properties! e-20507 s-20466))
+                      e-20507))
+                  (if (if (vector? x-20502)
+                        (if (= (vector-length x-20502) 4)
+                          (eq? (vector-ref x-20502 0) 'syntax-object)
                           #f)
                         #f)
-                    (let ((w-23096 (vector-ref x-23075 2)))
-                      (let ((ms-23097 (car w-23096))
-                            (ss-23098 (cdr w-23096)))
-                        (if (if (pair? ms-23097) (eq? (car ms-23097) #f) #f)
-                          (let ((expression-23106 (vector-ref x-23075 1))
-                                (wrap-23107
-                                  (cons (cdr ms-23097)
-                                        (if rib-23040
-                                          (cons rib-23040 (cdr ss-23098))
-                                          (cdr ss-23098))))
-                                (module-23108 (vector-ref x-23075 3)))
+                    (let ((w-20523 (vector-ref x-20502 2)))
+                      (let ((ms-20524 (car w-20523))
+                            (ss-20525 (cdr w-20523)))
+                        (if (if (pair? ms-20524) (eq? (car ms-20524) #f) #f)
+                          (let ((expression-20533 (vector-ref x-20502 1))
+                                (wrap-20534
+                                  (cons (cdr ms-20524)
+                                        (if rib-20467
+                                          (cons rib-20467 (cdr ss-20525))
+                                          (cdr ss-20525))))
+                                (module-20535 (vector-ref x-20502 3)))
                             (vector
                               'syntax-object
-                              expression-23106
-                              wrap-23107
-                              module-23108))
-                          (let ((expression-23118
-                                  (let ((e-23123 (vector-ref x-23075 1)))
+                              expression-20533
+                              wrap-20534
+                              module-20535))
+                          (let ((expression-20545
+                                  (let ((e-20550 (vector-ref x-20502 1)))
                                     (begin
-                                      (if (if s-23039
+                                      (if (if s-20466
                                             (supports-source-properties?
-                                              e-23123)
+                                              e-20550)
                                             #f)
                                         (set-source-properties!
-                                          e-23123
-                                          s-23039))
-                                      e-23123)))
-                                (wrap-23119
-                                  (cons (cons m-23076 ms-23097)
-                                        (if rib-23040
-                                          (cons rib-23040
-                                                (cons 'shift ss-23098))
-                                          (cons 'shift ss-23098))))
-                                (module-23120 (vector-ref x-23075 3)))
+                                          e-20550
+                                          s-20466))
+                                      e-20550)))
+                                (wrap-20546
+                                  (cons (cons m-20503 ms-20524)
+                                        (if rib-20467
+                                          (cons rib-20467
+                                                (cons 'shift ss-20525))
+                                          (cons 'shift ss-20525))))
+                                (module-20547 (vector-ref x-20502 3)))
                             (vector
                               'syntax-object
-                              expression-23118
-                              wrap-23119
-                              module-23120)))))
-                    (if (vector? x-23075)
-                      (let ((n-23135 (vector-length x-23075)))
-                        (let ((v-23136
-                                (let ((e-23144 (make-vector n-23135)))
+                              expression-20545
+                              wrap-20546
+                              module-20547)))))
+                    (if (vector? x-20502)
+                      (let ((n-20562 (vector-length x-20502)))
+                        (let ((v-20563
+                                (let ((e-20571 (make-vector n-20562)))
                                   (begin
-                                    (if (if s-23039
-                                          (supports-source-properties? e-23144)
+                                    (if (if s-20466
+                                          (supports-source-properties? e-20571)
                                           #f)
-                                      (set-source-properties! e-23144 s-23039))
-                                    e-23144))))
+                                      (set-source-properties! e-20571 s-20466))
+                                    e-20571))))
                           (letrec*
-                            ((loop-23137
-                               (lambda (i-23189)
-                                 (if (= i-23189 n-23135)
-                                   v-23136
+                            ((loop-20564
+                               (lambda (i-20616)
+                                 (if (= i-20616 n-20562)
+                                   v-20563
                                    (begin
                                      (vector-set!
-                                       v-23136
-                                       i-23189
-                                       (rebuild-macro-output-23042
-                                         (vector-ref x-23075 i-23189)
-                                         m-23076))
-                                     (loop-23137 (#{1+}# i-23189)))))))
-                            (loop-23137 0))))
-                      (if (symbol? x-23075)
+                                       v-20563
+                                       i-20616
+                                       (rebuild-macro-output-20469
+                                         (vector-ref x-20502 i-20616)
+                                         m-20503))
+                                     (loop-20564 (#{1+}# i-20616)))))))
+                            (loop-20564 0))))
+                      (if (symbol? x-20502)
                         (syntax-violation
                           #f
                           "encountered raw symbol in macro output"
-                          (let ((s-23195 (cdr w-23038)))
-                            (wrap-4324
+                          (let ((s-20622 (cdr w-20465)))
+                            (wrap-4290
                               (begin
-                                (if (if s-23195
-                                      (supports-source-properties? e-23036)
+                                (if (if s-20622
+                                      (supports-source-properties? e-20463)
                                       #f)
-                                  (set-source-properties! e-23036 s-23195))
-                                e-23036)
-                              w-23038
-                              mod-23041))
-                          x-23075)
+                                  (set-source-properties! e-20463 s-20622))
+                                e-20463)
+                              w-20465
+                              mod-20468))
+                          x-20502)
                         (begin
-                          (if (if s-23039
-                                (supports-source-properties? x-23075)
+                          (if (if s-20466
+                                (supports-source-properties? x-20502)
                                 #f)
-                            (set-source-properties! x-23075 s-23039))
-                          x-23075))))))))
+                            (set-source-properties! x-20502 s-20466))
+                          x-20502))))))))
            (with-fluids
-             ((transformer-environment-4317
-                (lambda (k-23043)
-                  (k-23043
-                    e-23036
-                    r-23037
-                    w-23038
-                    s-23039
-                    rib-23040
-                    mod-23041))))
-             (rebuild-macro-output-23042
-               (p-23035
-                 (let ((w-23050
-                         (cons (cons #f (car w-23038))
-                               (cons 'shift (cdr w-23038)))))
-                   (wrap-4324
+             ((transformer-environment-4283
+                (lambda (k-20470)
+                  (k-20470
+                    e-20463
+                    r-20464
+                    w-20465
+                    s-20466
+                    rib-20467
+                    mod-20468))))
+             (rebuild-macro-output-20469
+               (p-20462
+                 (let ((w-20477
+                         (cons (cons #f (car w-20465))
+                               (cons 'shift (cdr w-20465)))))
+                   (wrap-4290
                      (begin
-                       (if (if s-23039
-                             (supports-source-properties? e-23036)
+                       (if (if s-20466
+                             (supports-source-properties? e-20463)
                              #f)
-                         (set-source-properties! e-23036 s-23039))
-                       e-23036)
-                     w-23050
-                     mod-23041)))
+                         (set-source-properties! e-20463 s-20466))
+                       e-20463)
+                     w-20477
+                     mod-20468)))
                (gensym
-                 (string-append "m-" (session-id-4256) "-")))))))
-     (expand-body-4335
-       (lambda (body-23227
-                outer-form-23228
-                r-23229
-                w-23230
-                mod-23231)
-         (let ((r-23232
-                 (cons '("placeholder" placeholder) r-23229)))
-           (let ((ribcage-23233 (vector 'ribcage '() '() '())))
-             (let ((w-23234
-                     (cons (car w-23230)
-                           (cons ribcage-23233 (cdr w-23230)))))
+                 (string-append "m-" (session-id-4222) "-")))))))
+     (expand-body-4301
+       (lambda (body-20654
+                outer-form-20655
+                r-20656
+                w-20657
+                mod-20658)
+         (let ((r-20659
+                 (cons '("placeholder" placeholder) r-20656)))
+           (let ((ribcage-20660 (vector 'ribcage '() '() '())))
+             (let ((w-20661
+                     (cons (car w-20657)
+                           (cons ribcage-20660 (cdr w-20657)))))
                (letrec*
-                 ((parse-23235
-                    (lambda (body-23248
-                             ids-23249
-                             labels-23250
-                             var-ids-23251
-                             vars-23252
-                             vals-23253
-                             bindings-23254)
-                      (if (null? body-23248)
+                 ((parse-20662
+                    (lambda (body-20675
+                             ids-20676
+                             labels-20677
+                             var-ids-20678
+                             vars-20679
+                             vals-20680
+                             bindings-20681)
+                      (if (null? body-20675)
                         (syntax-violation
                           #f
                           "no expressions in body"
-                          outer-form-23228)
-                        (let ((e-23255 (cdr (car body-23248)))
-                              (er-23256 (car (car body-23248))))
+                          outer-form-20655)
+                        (let ((e-20682 (cdr (car body-20675)))
+                              (er-20683 (car (car body-20675))))
                           (call-with-values
                             (lambda ()
-                              (syntax-type-4330
-                                e-23255
-                                er-23256
+                              (syntax-type-4296
+                                e-20682
+                                er-20683
                                 '(())
-                                (source-annotation-4288 er-23256)
-                                ribcage-23233
-                                mod-23231
+                                (let ((props-20692
+                                        (source-properties
+                                          (if (if (vector? er-20683)
+                                                (if (= (vector-length er-20683)
+                                                       4)
+                                                  (eq? (vector-ref er-20683 0)
+                                                       'syntax-object)
+                                                  #f)
+                                                #f)
+                                            (vector-ref er-20683 1)
+                                            er-20683))))
+                                  (if (pair? props-20692) props-20692 #f))
+                                ribcage-20660
+                                mod-20658
                                 #f))
-                            (lambda (type-23413
-                                     value-23414
-                                     form-23415
-                                     e-23416
-                                     w-23417
-                                     s-23418
-                                     mod-23419)
-                              (if (eqv? type-23413 'define-form)
-                                (let ((id-23427
-                                        (wrap-4324
-                                          value-23414
-                                          w-23417
-                                          mod-23419))
-                                      (label-23428
+                            (lambda (type-20715
+                                     value-20716
+                                     form-20717
+                                     e-20718
+                                     w-20719
+                                     s-20720
+                                     mod-20721)
+                              (if (eqv? type-20715 'define-form)
+                                (let ((id-20729
+                                        (wrap-4290
+                                          value-20716
+                                          w-20719
+                                          mod-20721))
+                                      (label-20730
                                         (string-append
                                           "l-"
-                                          (session-id-4256)
+                                          (session-id-4222)
                                           (symbol->string (gensym "-")))))
-                                  (let ((var-23429
-                                          (let ((id-23489
-                                                  (if (if (vector? id-23427)
+                                  (let ((var-20731
+                                          (let ((id-20791
+                                                  (if (if (vector? id-20729)
                                                         (if (= (vector-length
-                                                                 id-23427)
+                                                                 id-20729)
                                                                4)
                                                           (eq? (vector-ref
-                                                                 id-23427
+                                                                 id-20729
                                                                  0)
                                                                'syntax-object)
                                                           #f)
                                                         #f)
-                                                    (vector-ref id-23427 1)
-                                                    id-23427)))
+                                                    (vector-ref id-20729 1)
+                                                    id-20729)))
                                             (gensym
                                               (string-append
-                                                (symbol->string id-23489)
+                                                (symbol->string id-20791)
                                                 "-")))))
                                     (begin
-                                      (let ((update-23479
-                                              (cons (vector-ref id-23427 1)
+                                      (let ((update-20781
+                                              (cons (vector-ref id-20729 1)
                                                     (vector-ref
-                                                      ribcage-23233
+                                                      ribcage-20660
                                                       1))))
                                         (vector-set!
-                                          ribcage-23233
+                                          ribcage-20660
                                           1
-                                          update-23479))
-                                      (let ((update-23481
+                                          update-20781))
+                                      (let ((update-20783
                                               (cons (car (vector-ref
-                                                           id-23427
+                                                           id-20729
                                                            2))
                                                     (vector-ref
-                                                      ribcage-23233
+                                                      ribcage-20660
                                                       2))))
                                         (vector-set!
-                                          ribcage-23233
+                                          ribcage-20660
                                           2
-                                          update-23481))
-                                      (let ((update-23483
-                                              (cons label-23428
+                                          update-20783))
+                                      (let ((update-20785
+                                              (cons label-20730
                                                     (vector-ref
-                                                      ribcage-23233
+                                                      ribcage-20660
                                                       3))))
                                         (vector-set!
-                                          ribcage-23233
+                                          ribcage-20660
                                           3
-                                          update-23483))
-                                      (parse-23235
-                                        (cdr body-23248)
-                                        (cons id-23427 ids-23249)
-                                        (cons label-23428 labels-23250)
-                                        (cons id-23427 var-ids-23251)
-                                        (cons var-23429 vars-23252)
-                                        (cons (cons er-23256
-                                                    (wrap-4324
-                                                      e-23416
-                                                      w-23417
-                                                      mod-23419))
-                                              vals-23253)
-                                        (cons (cons 'lexical var-23429)
-                                              bindings-23254)))))
-                                (if (if (eqv? type-23413 'define-syntax-form)
+                                          update-20785))
+                                      (parse-20662
+                                        (cdr body-20675)
+                                        (cons id-20729 ids-20676)
+                                        (cons label-20730 labels-20677)
+                                        (cons id-20729 var-ids-20678)
+                                        (cons var-20731 vars-20679)
+                                        (cons (cons er-20683
+                                                    (wrap-4290
+                                                      e-20718
+                                                      w-20719
+                                                      mod-20721))
+                                              vals-20680)
+                                        (cons (cons 'lexical var-20731)
+                                              bindings-20681)))))
+                                (if (if (eqv? type-20715 'define-syntax-form)
                                       #t
-                                      (eqv? type-23413
+                                      (eqv? type-20715
                                             'define-syntax-parameter-form))
-                                  (let ((id-23525
-                                          (wrap-4324
-                                            value-23414
-                                            w-23417
-                                            mod-23419))
-                                        (label-23526
+                                  (let ((id-20827
+                                          (wrap-4290
+                                            value-20716
+                                            w-20719
+                                            mod-20721))
+                                        (label-20828
                                           (string-append
                                             "l-"
-                                            (session-id-4256)
+                                            (session-id-4222)
                                             (symbol->string (gensym "-")))))
                                     (begin
-                                      (let ((update-23576
-                                              (cons (vector-ref id-23525 1)
+                                      (let ((update-20878
+                                              (cons (vector-ref id-20827 1)
                                                     (vector-ref
-                                                      ribcage-23233
+                                                      ribcage-20660
                                                       1))))
                                         (vector-set!
-                                          ribcage-23233
+                                          ribcage-20660
                                           1
-                                          update-23576))
-                                      (let ((update-23578
+                                          update-20878))
+                                      (let ((update-20880
                                               (cons (car (vector-ref
-                                                           id-23525
+                                                           id-20827
                                                            2))
                                                     (vector-ref
-                                                      ribcage-23233
+                                                      ribcage-20660
                                                       2))))
                                         (vector-set!
-                                          ribcage-23233
+                                          ribcage-20660
                                           2
-                                          update-23578))
-                                      (let ((update-23580
-                                              (cons label-23526
+                                          update-20880))
+                                      (let ((update-20882
+                                              (cons label-20828
                                                     (vector-ref
-                                                      ribcage-23233
+                                                      ribcage-20660
                                                       3))))
                                         (vector-set!
-                                          ribcage-23233
+                                          ribcage-20660
                                           3
-                                          update-23580))
-                                      (parse-23235
-                                        (cdr body-23248)
-                                        (cons id-23525 ids-23249)
-                                        (cons label-23526 labels-23250)
-                                        var-ids-23251
-                                        vars-23252
-                                        vals-23253
+                                          update-20882))
+                                      (parse-20662
+                                        (cdr body-20675)
+                                        (cons id-20827 ids-20676)
+                                        (cons label-20828 labels-20677)
+                                        var-ids-20678
+                                        vars-20679
+                                        vals-20680
                                         (cons (cons 'macro
-                                                    (cons er-23256
-                                                          (wrap-4324
-                                                            e-23416
-                                                            w-23417
-                                                            mod-23419)))
-                                              bindings-23254))))
-                                  (if (eqv? type-23413 'begin-form)
-                                    (let ((tmp-23591
+                                                    (cons er-20683
+                                                          (wrap-4290
+                                                            e-20718
+                                                            w-20719
+                                                            mod-20721)))
+                                              bindings-20681))))
+                                  (if (eqv? type-20715 'begin-form)
+                                    (let ((tmp-20893
                                             ($sc-dispatch
-                                              e-23416
+                                              e-20718
                                               '(_ . each-any))))
-                                      (if tmp-23591
+                                      (if tmp-20893
                                         (@apply
-                                          (lambda (e1-23595)
-                                            (parse-23235
+                                          (lambda (e1-20897)
+                                            (parse-20662
                                               (letrec*
-                                                ((f-23596
-                                                   (lambda (forms-23659)
-                                                     (if (null? forms-23659)
-                                                       (cdr body-23248)
-                                                       (cons (cons er-23256
-                                                                   (wrap-4324
-                                                                     (car 
forms-23659)
-                                                                     w-23417
-                                                                     
mod-23419))
-                                                             (f-23596
-                                                               (cdr 
forms-23659)))))))
-                                                (f-23596 e1-23595))
-                                              ids-23249
-                                              labels-23250
-                                              var-ids-23251
-                                              vars-23252
-                                              vals-23253
-                                              bindings-23254))
-                                          tmp-23591)
+                                                ((f-20898
+                                                   (lambda (forms-20961)
+                                                     (if (null? forms-20961)
+                                                       (cdr body-20675)
+                                                       (cons (cons er-20683
+                                                                   (wrap-4290
+                                                                     (car 
forms-20961)
+                                                                     w-20719
+                                                                     
mod-20721))
+                                                             (f-20898
+                                                               (cdr 
forms-20961)))))))
+                                                (f-20898 e1-20897))
+                                              ids-20676
+                                              labels-20677
+                                              var-ids-20678
+                                              vars-20679
+                                              vals-20680
+                                              bindings-20681))
+                                          tmp-20893)
                                         (syntax-violation
                                           #f
                                           "source expression failed to match 
any pattern"
-                                          e-23416)))
-                                    (if (eqv? type-23413 'local-syntax-form)
-                                      (expand-local-syntax-4336
-                                        value-23414
-                                        e-23416
-                                        er-23256
-                                        w-23417
-                                        s-23418
-                                        mod-23419
-                                        (lambda (forms-23676
-                                                 er-23677
-                                                 w-23678
-                                                 s-23679
-                                                 mod-23680)
-                                          (parse-23235
+                                          e-20718)))
+                                    (if (eqv? type-20715 'local-syntax-form)
+                                      (expand-local-syntax-4302
+                                        value-20716
+                                        e-20718
+                                        er-20683
+                                        w-20719
+                                        s-20720
+                                        mod-20721
+                                        (lambda (forms-20978
+                                                 er-20979
+                                                 w-20980
+                                                 s-20981
+                                                 mod-20982)
+                                          (parse-20662
                                             (letrec*
-                                              ((f-23681
-                                                 (lambda (forms-23744)
-                                                   (if (null? forms-23744)
-                                                     (cdr body-23248)
-                                                     (cons (cons er-23677
-                                                                 (wrap-4324
-                                                                   (car 
forms-23744)
-                                                                   w-23678
-                                                                   mod-23680))
-                                                           (f-23681
-                                                             (cdr 
forms-23744)))))))
-                                              (f-23681 forms-23676))
-                                            ids-23249
-                                            labels-23250
-                                            var-ids-23251
-                                            vars-23252
-                                            vals-23253
-                                            bindings-23254)))
-                                      (if (null? ids-23249)
-                                        (build-sequence-4276
-                                          #f
-                                          (map (lambda (x-23809)
-                                                 (let ((e-23813 (cdr x-23809))
-                                                       (r-23814 (car x-23809)))
-                                                   (call-with-values
-                                                     (lambda ()
-                                                       (syntax-type-4330
-                                                         e-23813
-                                                         r-23814
-                                                         '(())
-                                                         
(source-annotation-4288
-                                                           e-23813)
-                                                         #f
-                                                         mod-23419
-                                                         #f))
-                                                     (lambda (type-23818
-                                                              value-23819
-                                                              form-23820
-                                                              e-23821
-                                                              w-23822
-                                                              s-23823
-                                                              mod-23824)
-                                                       (expand-expr-4332
-                                                         type-23818
-                                                         value-23819
-                                                         form-23820
-                                                         e-23821
-                                                         r-23814
-                                                         w-23822
-                                                         s-23823
-                                                         mod-23824)))))
-                                               (cons (cons er-23256
-                                                           (wrap-4324
-                                                             (begin
-                                                               (if (if s-23418
-                                                                     
(supports-source-properties?
-                                                                       e-23416)
-                                                                     #f)
-                                                                 
(set-source-properties!
-                                                                   e-23416
-                                                                   s-23418))
-                                                               e-23416)
-                                                             w-23417
-                                                             mod-23419))
-                                                     (cdr body-23248))))
+                                              ((f-20983
+                                                 (lambda (forms-21046)
+                                                   (if (null? forms-21046)
+                                                     (cdr body-20675)
+                                                     (cons (cons er-20979
+                                                                 (wrap-4290
+                                                                   (car 
forms-21046)
+                                                                   w-20980
+                                                                   mod-20982))
+                                                           (f-20983
+                                                             (cdr 
forms-21046)))))))
+                                              (f-20983 forms-20978))
+                                            ids-20676
+                                            labels-20677
+                                            var-ids-20678
+                                            vars-20679
+                                            vals-20680
+                                            bindings-20681)))
+                                      (if (null? ids-20676)
+                                        (let ((exps-21053
+                                                (map (lambda (x-21054)
+                                                       (let ((e-21057
+                                                               (cdr x-21054))
+                                                             (r-21058
+                                                               (car x-21054)))
+                                                         (call-with-values
+                                                           (lambda ()
+                                                             (syntax-type-4296
+                                                               e-21057
+                                                               r-21058
+                                                               '(())
+                                                               (let 
((props-21065
+                                                                       
(source-properties
+                                                                         (if 
(if (vector?
+                                                                               
    e-21057)
+                                                                               
(if (= (vector-length
+                                                                               
         e-21057)
+                                                                               
       4)
+                                                                               
  (eq? (vector-ref
+                                                                               
         e-21057
+                                                                               
         0)
+                                                                               
       'syntax-object)
+                                                                               
  #f)
+                                                                               
#f)
+                                                                           
(vector-ref
+                                                                             
e-21057
+                                                                             1)
+                                                                           
e-21057))))
+                                                                 (if (pair? 
props-21065)
+                                                                   props-21065
+                                                                   #f))
+                                                               #f
+                                                               mod-20721
+                                                               #f))
+                                                           (lambda (type-21088
+                                                                    value-21089
+                                                                    form-21090
+                                                                    e-21091
+                                                                    w-21092
+                                                                    s-21093
+                                                                    mod-21094)
+                                                             (expand-expr-4298
+                                                               type-21088
+                                                               value-21089
+                                                               form-21090
+                                                               e-21091
+                                                               r-21058
+                                                               w-21092
+                                                               s-21093
+                                                               mod-21094)))))
+                                                     (cons (cons er-20683
+                                                                 (wrap-4290
+                                                                   (begin
+                                                                     (if (if 
s-20720
+                                                                           
(supports-source-properties?
+                                                                             
e-20718)
+                                                                           #f)
+                                                                       
(set-source-properties!
+                                                                         
e-20718
+                                                                         
s-20720))
+                                                                     e-20718)
+                                                                   w-20719
+                                                                   mod-20721))
+                                                           (cdr body-20675)))))
+                                          (if (null? (cdr exps-21053))
+                                            (car exps-21053)
+                                            (make-struct/no-tail
+                                              (vector-ref %expanded-vtables 12)
+                                              #f
+                                              exps-21053)))
                                         (begin
-                                          (if (not (valid-bound-ids?-4321
-                                                     ids-23249))
+                                          (if (not (valid-bound-ids?-4287
+                                                     ids-20676))
                                             (syntax-violation
                                               #f
                                               "invalid or duplicate identifier 
in definition"
-                                              outer-form-23228))
+                                              outer-form-20655))
                                           (letrec*
-                                            ((loop-23925
-                                               (lambda (bs-23928
-                                                        er-cache-23929
-                                                        r-cache-23930)
-                                                 (if (not (null? bs-23928))
-                                                   (let ((b-23931
-                                                           (car bs-23928)))
-                                                     (if (eq? (car b-23931)
+                                            ((loop-21197
+                                               (lambda (bs-21200
+                                                        er-cache-21201
+                                                        r-cache-21202)
+                                                 (if (not (null? bs-21200))
+                                                   (let ((b-21203
+                                                           (car bs-21200)))
+                                                     (if (eq? (car b-21203)
                                                               'macro)
-                                                       (let ((er-23933
-                                                               (car (cdr 
b-23931))))
-                                                         (let ((r-cache-23934
-                                                                 (if (eq? 
er-23933
-                                                                          
er-cache-23929)
-                                                                   
r-cache-23930
-                                                                   
(macros-only-env-4291
-                                                                     
er-23933))))
+                                                       (let ((er-21205
+                                                               (car (cdr 
b-21203))))
+                                                         (let ((r-cache-21206
+                                                                 (if (eq? 
er-21205
+                                                                          
er-cache-21201)
+                                                                   
r-cache-21202
+                                                                   
(macros-only-env-4257
+                                                                     
er-21205))))
                                                            (begin
                                                              (set-cdr!
-                                                               b-23931
-                                                               
(eval-local-transformer-4337
-                                                                 (expand-4331
-                                                                   (cdr (cdr 
b-23931))
-                                                                   
r-cache-23934
-                                                                   '(())
-                                                                   mod-23419)
-                                                                 mod-23419))
-                                                             (loop-23925
-                                                               (cdr bs-23928)
-                                                               er-23933
-                                                               
r-cache-23934))))
-                                                       (loop-23925
-                                                         (cdr bs-23928)
-                                                         er-cache-23929
-                                                         r-cache-23930)))))))
-                                            (loop-23925 bindings-23254 #f #f))
+                                                               b-21203
+                                                               
(eval-local-transformer-4303
+                                                                 (let ((e-21249
+                                                                         (cdr 
(cdr b-21203))))
+                                                                   
(call-with-values
+                                                                     (lambda ()
+                                                                       
(syntax-type-4296
+                                                                         
e-21249
+                                                                         
r-cache-21206
+                                                                         '(())
+                                                                         (let 
((props-21259
+                                                                               
  (source-properties
+                                                                               
    (if (if (vector?
+                                                                               
              e-21249)
+                                                                               
          (if (= (vector-length
+                                                                               
                   e-21249)
+                                                                               
                 4)
+                                                                               
            (eq? (vector-ref
+                                                                               
                   e-21249
+                                                                               
                   0)
+                                                                               
                 'syntax-object)
+                                                                               
            #f)
+                                                                               
          #f)
+                                                                               
      (vector-ref
+                                                                               
        e-21249
+                                                                               
        1)
+                                                                               
      e-21249))))
+                                                                           (if 
(pair? props-21259)
+                                                                             
props-21259
+                                                                             
#f))
+                                                                         #f
+                                                                         
mod-20721
+                                                                         #f))
+                                                                     (lambda 
(type-21282
+                                                                              
value-21283
+                                                                              
form-21284
+                                                                              
e-21285
+                                                                              
w-21286
+                                                                              
s-21287
+                                                                              
mod-21288)
+                                                                       
(expand-expr-4298
+                                                                         
type-21282
+                                                                         
value-21283
+                                                                         
form-21284
+                                                                         
e-21285
+                                                                         
r-cache-21206
+                                                                         
w-21286
+                                                                         
s-21287
+                                                                         
mod-21288))))
+                                                                 mod-20721))
+                                                             (loop-21197
+                                                               (cdr bs-21200)
+                                                               er-21205
+                                                               
r-cache-21206))))
+                                                       (loop-21197
+                                                         (cdr bs-21200)
+                                                         er-cache-21201
+                                                         r-cache-21202)))))))
+                                            (loop-21197 bindings-20681 #f #f))
                                           (set-cdr!
-                                            r-23232
-                                            (extend-env-4289
-                                              labels-23250
-                                              bindings-23254
-                                              (cdr r-23232)))
-                                          (build-letrec-4279
-                                            #f
-                                            #t
-                                            (reverse
-                                              (map syntax->datum
-                                                   var-ids-23251))
-                                            (reverse vars-23252)
-                                            (map (lambda (x-24277)
-                                                   (let ((e-24281
-                                                           (cdr x-24277))
-                                                         (r-24282
-                                                           (car x-24277)))
-                                                     (call-with-values
-                                                       (lambda ()
-                                                         (syntax-type-4330
-                                                           e-24281
-                                                           r-24282
-                                                           '(())
-                                                           
(source-annotation-4288
-                                                             e-24281)
-                                                           #f
-                                                           mod-23419
-                                                           #f))
-                                                       (lambda (type-24286
-                                                                value-24287
-                                                                form-24288
-                                                                e-24289
-                                                                w-24290
-                                                                s-24291
-                                                                mod-24292)
-                                                         (expand-expr-4332
-                                                           type-24286
-                                                           value-24287
-                                                           form-24288
-                                                           e-24289
-                                                           r-24282
-                                                           w-24290
-                                                           s-24291
-                                                           mod-24292)))))
-                                                 (reverse vals-23253))
-                                            (let ((exps-24298
-                                                    (map (lambda (x-24299)
-                                                           (let ((e-24302
-                                                                   (cdr 
x-24299))
-                                                                 (r-24303
-                                                                   (car 
x-24299)))
-                                                             (call-with-values
-                                                               (lambda ()
-                                                                 
(syntax-type-4330
-                                                                   e-24302
-                                                                   r-24303
-                                                                   '(())
-                                                                   
(source-annotation-4288
-                                                                     e-24302)
-                                                                   #f
-                                                                   mod-23419
-                                                                   #f))
-                                                               (lambda 
(type-24307
-                                                                        
value-24308
-                                                                        
form-24309
-                                                                        e-24310
-                                                                        w-24311
-                                                                        s-24312
-                                                                        
mod-24313)
-                                                                 
(expand-expr-4332
-                                                                   type-24307
-                                                                   value-24308
-                                                                   form-24309
-                                                                   e-24310
-                                                                   r-24303
-                                                                   w-24311
-                                                                   s-24312
-                                                                   
mod-24313)))))
-                                                         (cons (cons er-23256
-                                                                     (wrap-4324
-                                                                       (begin
-                                                                         (if 
(if s-23418
-                                                                               
(supports-source-properties?
-                                                                               
  e-23416)
-                                                                               
#f)
-                                                                           
(set-source-properties!
-                                                                             
e-23416
-                                                                             
s-23418))
-                                                                         
e-23416)
-                                                                       w-23417
-                                                                       
mod-23419))
-                                                               (cdr 
body-23248)))))
-                                              (if (null? (cdr exps-24298))
-                                                (car exps-24298)
+                                            r-20659
+                                            (extend-env-4255
+                                              labels-20677
+                                              bindings-20681
+                                              (cdr r-20659)))
+                                          (let ((ids-21471
+                                                  (reverse
+                                                    (map syntax->datum
+                                                         var-ids-20678)))
+                                                (vars-21472
+                                                  (reverse vars-20679))
+                                                (val-exps-21473
+                                                  (map (lambda (x-21560)
+                                                         (let ((e-21563
+                                                                 (cdr x-21560))
+                                                               (r-21564
+                                                                 (car 
x-21560)))
+                                                           (call-with-values
+                                                             (lambda ()
+                                                               
(syntax-type-4296
+                                                                 e-21563
+                                                                 r-21564
+                                                                 '(())
+                                                                 (let 
((props-21571
+                                                                         
(source-properties
+                                                                           (if 
(if (vector?
+                                                                               
      e-21563)
+                                                                               
  (if (= (vector-length
+                                                                               
           e-21563)
+                                                                               
         4)
+                                                                               
    (eq? (vector-ref
+                                                                               
           e-21563
+                                                                               
           0)
+                                                                               
         'syntax-object)
+                                                                               
    #f)
+                                                                               
  #f)
+                                                                             
(vector-ref
+                                                                               
e-21563
+                                                                               
1)
+                                                                             
e-21563))))
+                                                                   (if (pair? 
props-21571)
+                                                                     
props-21571
+                                                                     #f))
+                                                                 #f
+                                                                 mod-20721
+                                                                 #f))
+                                                             (lambda 
(type-21594
+                                                                      
value-21595
+                                                                      
form-21596
+                                                                      e-21597
+                                                                      w-21598
+                                                                      s-21599
+                                                                      
mod-21600)
+                                                               
(expand-expr-4298
+                                                                 type-21594
+                                                                 value-21595
+                                                                 form-21596
+                                                                 e-21597
+                                                                 r-21564
+                                                                 w-21598
+                                                                 s-21599
+                                                                 mod-21600)))))
+                                                       (reverse vals-20680)))
+                                                (body-exp-21474
+                                                  (let ((exps-21478
+                                                          (map (lambda 
(x-21479)
+                                                                 (let ((e-21482
+                                                                         (cdr 
x-21479))
+                                                                       (r-21483
+                                                                         (car 
x-21479)))
+                                                                   
(call-with-values
+                                                                     (lambda ()
+                                                                       
(syntax-type-4296
+                                                                         
e-21482
+                                                                         
r-21483
+                                                                         '(())
+                                                                         (let 
((props-21490
+                                                                               
  (source-properties
+                                                                               
    (if (if (vector?
+                                                                               
              e-21482)
+                                                                               
          (if (= (vector-length
+                                                                               
                   e-21482)
+                                                                               
                 4)
+                                                                               
            (eq? (vector-ref
+                                                                               
                   e-21482
+                                                                               
                   0)
+                                                                               
                 'syntax-object)
+                                                                               
            #f)
+                                                                               
          #f)
+                                                                               
      (vector-ref
+                                                                               
        e-21482
+                                                                               
        1)
+                                                                               
      e-21482))))
+                                                                           (if 
(pair? props-21490)
+                                                                             
props-21490
+                                                                             
#f))
+                                                                         #f
+                                                                         
mod-20721
+                                                                         #f))
+                                                                     (lambda 
(type-21513
+                                                                              
value-21514
+                                                                              
form-21515
+                                                                              
e-21516
+                                                                              
w-21517
+                                                                              
s-21518
+                                                                              
mod-21519)
+                                                                       
(expand-expr-4298
+                                                                         
type-21513
+                                                                         
value-21514
+                                                                         
form-21515
+                                                                         
e-21516
+                                                                         
r-21483
+                                                                         
w-21517
+                                                                         
s-21518
+                                                                         
mod-21519)))))
+                                                               (cons (cons 
er-20683
+                                                                           
(wrap-4290
+                                                                             
(begin
+                                                                               
(if (if s-20720
+                                                                               
      (supports-source-properties?
+                                                                               
        e-20718)
+                                                                               
      #f)
+                                                                               
  (set-source-properties!
+                                                                               
    e-20718
+                                                                               
    s-20720))
+                                                                               
e-20718)
+                                                                             
w-20719
+                                                                             
mod-20721))
+                                                                     (cdr 
body-20675)))))
+                                                    (if (null? (cdr 
exps-21478))
+                                                      (car exps-21478)
+                                                      (make-struct/no-tail
+                                                        (vector-ref
+                                                          %expanded-vtables
+                                                          12)
+                                                        #f
+                                                        exps-21478)))))
+                                            (if (null? vars-21472)
+                                              body-exp-21474
+                                              (begin
+                                                (for-each
+                                                  maybe-name-value!-4226
+                                                  ids-21471
+                                                  val-exps-21473)
                                                 (make-struct/no-tail
                                                   (vector-ref
                                                     %expanded-vtables
-                                                    12)
+                                                    16)
                                                   #f
-                                                  exps-24298)))))))))))))))))
-                 (parse-23235
-                   (map (lambda (x-23238)
-                          (cons r-23232
-                                (wrap-4324 x-23238 w-23234 mod-23231)))
-                        body-23227)
+                                                  #t
+                                                  ids-21471
+                                                  vars-21472
+                                                  val-exps-21473
+                                                  
body-exp-21474)))))))))))))))))
+                 (parse-20662
+                   (map (lambda (x-20665)
+                          (cons r-20659
+                                (wrap-4290 x-20665 w-20661 mod-20658)))
+                        body-20654)
                    '()
                    '()
                    '()
                    '()
                    '()
                    '())))))))
-     (expand-local-syntax-4336
-       (lambda (rec?-24339
-                e-24340
-                r-24341
-                w-24342
-                s-24343
-                mod-24344
-                k-24345)
-         (let ((tmp-24347
+     (expand-local-syntax-4302
+       (lambda (rec?-21610
+                e-21611
+                r-21612
+                w-21613
+                s-21614
+                mod-21615
+                k-21616)
+         (let ((tmp-21618
                  ($sc-dispatch
-                   e-24340
+                   e-21611
                    '(_ #(each (any any)) any . each-any))))
-           (if tmp-24347
+           (if tmp-21618
              (@apply
-               (lambda (id-24351 val-24352 e1-24353 e2-24354)
-                 (if (not (valid-bound-ids?-4321 id-24351))
+               (lambda (id-21620 val-21621 e1-21622 e2-21623)
+                 (if (not (valid-bound-ids?-4287 id-21620))
                    (syntax-violation
                      #f
                      "duplicate bound keyword"
-                     e-24340)
-                   (let ((labels-24444 (gen-labels-4298 id-24351)))
-                     (let ((new-w-24445
-                             (make-binding-wrap-4309
-                               id-24351
-                               labels-24444
-                               w-24342)))
-                       (k-24345
-                         (cons e1-24353 e2-24354)
-                         (extend-env-4289
-                           labels-24444
-                           (let ((trans-r-24481
-                                   (macros-only-env-4291 r-24341)))
+                     e-21611)
+                   (let ((labels-21713 (gen-labels-4264 id-21620)))
+                     (let ((new-w-21714
+                             (make-binding-wrap-4275
+                               id-21620
+                               labels-21713
+                               w-21613)))
+                       (k-21616
+                         (cons e1-21622 e2-21623)
+                         (extend-env-4255
+                           labels-21713
+                           (let ((trans-r-21750
+                                   (macros-only-env-4257 r-21612)))
                              (begin
-                               (if rec?-24339 new-w-24445 w-24342)
-                               (map (lambda (x-24482)
+                               (if rec?-21610 new-w-21714 w-21613)
+                               (map (lambda (x-21751)
                                       (cons 'macro
-                                            (eval-local-transformer-4337
-                                              (expand-4331
-                                                x-24482
-                                                trans-r-24481
-                                                (values
-                                                  (if rec?-24339
-                                                    new-w-24445
-                                                    w-24342))
-                                                mod-24344)
-                                              mod-24344)))
-                                    val-24352)))
-                           r-24341)
-                         new-w-24445
-                         s-24343
-                         mod-24344)))))
-               tmp-24347)
+                                            (eval-local-transformer-4303
+                                              (call-with-values
+                                                (lambda ()
+                                                  (syntax-type-4296
+                                                    x-21751
+                                                    trans-r-21750
+                                                    (values
+                                                      (if rec?-21610
+                                                        new-w-21714
+                                                        w-21613))
+                                                    (let ((props-21811
+                                                            (source-properties
+                                                              (if (if (vector?
+                                                                        
x-21751)
+                                                                    (if (= 
(vector-length
+                                                                             
x-21751)
+                                                                           4)
+                                                                      (eq? 
(vector-ref
+                                                                             
x-21751
+                                                                             0)
+                                                                           
'syntax-object)
+                                                                      #f)
+                                                                    #f)
+                                                                (vector-ref
+                                                                  x-21751
+                                                                  1)
+                                                                x-21751))))
+                                                      (if (pair? props-21811)
+                                                        props-21811
+                                                        #f))
+                                                    #f
+                                                    mod-21615
+                                                    #f))
+                                                (lambda (type-21844
+                                                         value-21845
+                                                         form-21846
+                                                         e-21847
+                                                         w-21848
+                                                         s-21849
+                                                         mod-21850)
+                                                  (expand-expr-4298
+                                                    type-21844
+                                                    value-21845
+                                                    form-21846
+                                                    e-21847
+                                                    trans-r-21750
+                                                    w-21848
+                                                    s-21849
+                                                    mod-21850)))
+                                              mod-21615)))
+                                    val-21621)))
+                           r-21612)
+                         new-w-21714
+                         s-21614
+                         mod-21615)))))
+               tmp-21618)
              (syntax-violation
                #f
                "bad local syntax definition"
-               (wrap-4324
+               (wrap-4290
                  (begin
-                   (if (if s-24343
-                         (supports-source-properties? e-24340)
+                   (if (if s-21614
+                         (supports-source-properties? e-21611)
                          #f)
-                     (set-source-properties! e-24340 s-24343))
-                   e-24340)
-                 w-24342
-                 mod-24344))))))
-     (eval-local-transformer-4337
-       (lambda (expanded-24762 mod-24763)
-         (let ((p-24764 (primitive-eval expanded-24762)))
-           (if (procedure? p-24764)
-             p-24764
+                     (set-source-properties! e-21611 s-21614))
+                   e-21611)
+                 w-21613
+                 mod-21615))))))
+     (eval-local-transformer-4303
+       (lambda (expanded-22016 mod-22017)
+         (let ((p-22018 (primitive-eval expanded-22016)))
+           (if (procedure? p-22018)
+             p-22018
              (syntax-violation
                #f
                "nonprocedure transformer"
-               p-24764)))))
-     (ellipsis?-4339
-       (lambda (x-5000)
-         (if (if (if (vector? x-5000)
-                   (if (= (vector-length x-5000) 4)
-                     (eq? (vector-ref x-5000 0) 'syntax-object)
+               p-22018)))))
+     (ellipsis?-4305
+       (lambda (x-4941)
+         (if (if (if (vector? x-4941)
+                   (if (= (vector-length x-4941) 4)
+                     (eq? (vector-ref x-4941 0) 'syntax-object)
                      #f)
                    #f)
-               (symbol? (vector-ref x-5000 1))
+               (symbol? (vector-ref x-4941 1))
                #f)
-           (if (eq? (if (if (vector? x-5000)
-                          (if (= (vector-length x-5000) 4)
-                            (eq? (vector-ref x-5000 0) 'syntax-object)
+           (if (eq? (if (if (vector? x-4941)
+                          (if (= (vector-length x-4941) 4)
+                            (eq? (vector-ref x-4941 0) 'syntax-object)
                             #f)
                           #f)
-                      (vector-ref x-5000 1)
-                      x-5000)
+                      (vector-ref x-4941 1)
+                      x-4941)
                     (if (if (= (vector-length
                                  '#(syntax-object
                                     ...
                                     ((top)
                                      #(ribcage () () ())
                                      #(ribcage () () ())
-                                     #(ribcage #(x) #((top)) #("l-*-2267"))
+                                     #(ribcage #(x) #((top)) #("l-*-2265"))
                                      #(ribcage
                                        (lambda-var-list
                                          gen-var
@@ -5313,7 +5944,7 @@
                          ((top)
                           #(ribcage () () ())
                           #(ribcage () () ())
-                          #(ribcage #(x) #((top)) #("l-*-2267"))
+                          #(ribcage #(x) #((top)) #("l-*-2265"))
                           #(ribcage
                             (lambda-var-list
                               gen-var
@@ -5742,14 +6373,14 @@
                             ((top) (top) (top))
                             ("l-*-47" "l-*-46" "l-*-45")))
                          (hygiene guile))))
-             (eq? (id-var-name-4314 x-5000 '(()))
-                  (id-var-name-4314
+             (eq? (id-var-name-4280 x-4941 '(()))
+                  (id-var-name-4280
                     '#(syntax-object
                        ...
                        ((top)
                         #(ribcage () () ())
                         #(ribcage () () ())
-                        #(ribcage #(x) #((top)) #("l-*-2267"))
+                        #(ribcage #(x) #((top)) #("l-*-2265"))
                         #(ribcage
                           (lambda-var-list
                             gen-var
@@ -6181,272 +6812,272 @@
                     '(())))
              #f)
            #f)))
-     (lambda-formals-4340
-       (lambda (orig-args-24769)
+     (lambda-formals-4306
+       (lambda (orig-args-22023)
          (letrec*
-           ((req-24770
-              (lambda (args-24774 rreq-24775)
-                (let ((tmp-24777 ($sc-dispatch args-24774 '())))
-                  (if tmp-24777
+           ((req-22024
+              (lambda (args-22028 rreq-22029)
+                (let ((tmp-22031 ($sc-dispatch args-22028 '())))
+                  (if tmp-22031
                     (@apply
-                      (lambda () (check-24771 (reverse rreq-24775) #f))
-                      tmp-24777)
-                    (let ((tmp-24900
-                            ($sc-dispatch args-24774 '(any . any))))
-                      (if (if tmp-24900
+                      (lambda () (check-22025 (reverse rreq-22029) #f))
+                      tmp-22031)
+                    (let ((tmp-22154
+                            ($sc-dispatch args-22028 '(any . any))))
+                      (if (if tmp-22154
                             (@apply
-                              (lambda (a-24904 b-24905)
-                                (if (symbol? a-24904)
+                              (lambda (a-22158 b-22159)
+                                (if (symbol? a-22158)
                                   #t
-                                  (if (if (vector? a-24904)
-                                        (if (= (vector-length a-24904) 4)
-                                          (eq? (vector-ref a-24904 0)
+                                  (if (if (vector? a-22158)
+                                        (if (= (vector-length a-22158) 4)
+                                          (eq? (vector-ref a-22158 0)
                                                'syntax-object)
                                           #f)
                                         #f)
-                                    (symbol? (vector-ref a-24904 1))
+                                    (symbol? (vector-ref a-22158 1))
                                     #f)))
-                              tmp-24900)
+                              tmp-22154)
                             #f)
                         (@apply
-                          (lambda (a-24932 b-24933)
-                            (req-24770 b-24933 (cons a-24932 rreq-24775)))
-                          tmp-24900)
-                        (let ((tmp-24934 (list args-24774)))
+                          (lambda (a-22186 b-22187)
+                            (req-22024 b-22187 (cons a-22186 rreq-22029)))
+                          tmp-22154)
+                        (let ((tmp-22188 (list args-22028)))
                           (if (@apply
-                                (lambda (r-24936)
-                                  (if (symbol? r-24936)
+                                (lambda (r-22190)
+                                  (if (symbol? r-22190)
                                     #t
-                                    (if (if (vector? r-24936)
-                                          (if (= (vector-length r-24936) 4)
-                                            (eq? (vector-ref r-24936 0)
+                                    (if (if (vector? r-22190)
+                                          (if (= (vector-length r-22190) 4)
+                                            (eq? (vector-ref r-22190 0)
                                                  'syntax-object)
                                             #f)
                                           #f)
-                                      (symbol? (vector-ref r-24936 1))
+                                      (symbol? (vector-ref r-22190 1))
                                       #f)))
-                                tmp-24934)
+                                tmp-22188)
                             (@apply
-                              (lambda (r-24966)
-                                (check-24771 (reverse rreq-24775) r-24966))
-                              tmp-24934)
+                              (lambda (r-22220)
+                                (check-22025 (reverse rreq-22029) r-22220))
+                              tmp-22188)
                             (syntax-violation
                               'lambda
                               "invalid argument list"
-                              orig-args-24769
-                              args-24774)))))))))
-            (check-24771
-              (lambda (req-25097 rest-25098)
-                (if (distinct-bound-ids?-4322
-                      (if rest-25098
-                        (cons rest-25098 req-25097)
-                        req-25097))
-                  (values req-25097 #f rest-25098 #f)
+                              orig-args-22023
+                              args-22028)))))))))
+            (check-22025
+              (lambda (req-22351 rest-22352)
+                (if (distinct-bound-ids?-4288
+                      (if rest-22352
+                        (cons rest-22352 req-22351)
+                        req-22351))
+                  (values req-22351 #f rest-22352 #f)
                   (syntax-violation
                     'lambda
                     "duplicate identifier in argument list"
-                    orig-args-24769)))))
-           (req-24770 orig-args-24769 '()))))
-     (expand-simple-lambda-4341
-       (lambda (e-25214
-                r-25215
-                w-25216
-                s-25217
-                mod-25218
-                req-25219
-                rest-25220
-                meta-25221
-                body-25222)
-         (let ((ids-25223
-                 (if rest-25220
-                   (append req-25219 (list rest-25220))
-                   req-25219)))
-           (let ((vars-25224 (map gen-var-4345 ids-25223)))
-             (let ((labels-25225 (gen-labels-4298 ids-25223)))
-               (build-simple-lambda-4271
-                 s-25217
-                 (map syntax->datum req-25219)
-                 (if rest-25220 (syntax->datum rest-25220) #f)
-                 vars-25224
-                 meta-25221
-                 (expand-body-4335
-                   body-25222
-                   (wrap-4324
+                    orig-args-22023)))))
+           (req-22024 orig-args-22023 '()))))
+     (expand-simple-lambda-4307
+       (lambda (e-22468
+                r-22469
+                w-22470
+                s-22471
+                mod-22472
+                req-22473
+                rest-22474
+                meta-22475
+                body-22476)
+         (let ((ids-22477
+                 (if rest-22474
+                   (append req-22473 (list rest-22474))
+                   req-22473)))
+           (let ((vars-22478 (map gen-var-4311 ids-22477)))
+             (let ((labels-22479 (gen-labels-4264 ids-22477)))
+               (build-simple-lambda-4237
+                 s-22471
+                 (map syntax->datum req-22473)
+                 (if rest-22474 (syntax->datum rest-22474) #f)
+                 vars-22478
+                 meta-22475
+                 (expand-body-4301
+                   body-22476
+                   (wrap-4290
                      (begin
-                       (if (if s-25217
-                             (supports-source-properties? e-25214)
+                       (if (if s-22471
+                             (supports-source-properties? e-22468)
                              #f)
-                         (set-source-properties! e-25214 s-25217))
-                       e-25214)
-                     w-25216
-                     mod-25218)
-                   (extend-var-env-4290
-                     labels-25225
-                     vars-25224
-                     r-25215)
-                   (make-binding-wrap-4309
-                     ids-25223
-                     labels-25225
-                     w-25216)
-                   mod-25218)))))))
-     (lambda*-formals-4342
-       (lambda (orig-args-25505)
+                         (set-source-properties! e-22468 s-22471))
+                       e-22468)
+                     w-22470
+                     mod-22472)
+                   (extend-var-env-4256
+                     labels-22479
+                     vars-22478
+                     r-22469)
+                   (make-binding-wrap-4275
+                     ids-22477
+                     labels-22479
+                     w-22470)
+                   mod-22472)))))))
+     (lambda*-formals-4308
+       (lambda (orig-args-22759)
          (letrec*
-           ((req-25506
-              (lambda (args-25513 rreq-25514)
-                (let ((tmp-25516 ($sc-dispatch args-25513 '())))
-                  (if tmp-25516
+           ((req-22760
+              (lambda (args-22767 rreq-22768)
+                (let ((tmp-22770 ($sc-dispatch args-22767 '())))
+                  (if tmp-22770
                     (@apply
                       (lambda ()
-                        (check-25510 (reverse rreq-25514) '() #f '()))
-                      tmp-25516)
-                    (let ((tmp-25522
-                            ($sc-dispatch args-25513 '(any . any))))
-                      (if (if tmp-25522
+                        (check-22764 (reverse rreq-22768) '() #f '()))
+                      tmp-22770)
+                    (let ((tmp-22776
+                            ($sc-dispatch args-22767 '(any . any))))
+                      (if (if tmp-22776
                             (@apply
-                              (lambda (a-25526 b-25527)
-                                (if (symbol? a-25526)
+                              (lambda (a-22780 b-22781)
+                                (if (symbol? a-22780)
                                   #t
-                                  (if (if (vector? a-25526)
-                                        (if (= (vector-length a-25526) 4)
-                                          (eq? (vector-ref a-25526 0)
+                                  (if (if (vector? a-22780)
+                                        (if (= (vector-length a-22780) 4)
+                                          (eq? (vector-ref a-22780 0)
                                                'syntax-object)
                                           #f)
                                         #f)
-                                    (symbol? (vector-ref a-25526 1))
+                                    (symbol? (vector-ref a-22780 1))
                                     #f)))
-                              tmp-25522)
+                              tmp-22776)
                             #f)
                         (@apply
-                          (lambda (a-25554 b-25555)
-                            (req-25506 b-25555 (cons a-25554 rreq-25514)))
-                          tmp-25522)
-                        (let ((tmp-25556
-                                ($sc-dispatch args-25513 '(any . any))))
-                          (if (if tmp-25556
+                          (lambda (a-22808 b-22809)
+                            (req-22760 b-22809 (cons a-22808 rreq-22768)))
+                          tmp-22776)
+                        (let ((tmp-22810
+                                ($sc-dispatch args-22767 '(any . any))))
+                          (if (if tmp-22810
                                 (@apply
-                                  (lambda (a-25560 b-25561)
-                                    (eq? (syntax->datum a-25560) #:optional))
-                                  tmp-25556)
+                                  (lambda (a-22814 b-22815)
+                                    (eq? (syntax->datum a-22814) #:optional))
+                                  tmp-22810)
                                 #f)
                             (@apply
-                              (lambda (a-25562 b-25563)
-                                (opt-25507 b-25563 (reverse rreq-25514) '()))
-                              tmp-25556)
-                            (let ((tmp-25566
-                                    ($sc-dispatch args-25513 '(any . any))))
-                              (if (if tmp-25566
+                              (lambda (a-22816 b-22817)
+                                (opt-22761 b-22817 (reverse rreq-22768) '()))
+                              tmp-22810)
+                            (let ((tmp-22820
+                                    ($sc-dispatch args-22767 '(any . any))))
+                              (if (if tmp-22820
                                     (@apply
-                                      (lambda (a-25570 b-25571)
-                                        (eq? (syntax->datum a-25570) #:key))
-                                      tmp-25566)
+                                      (lambda (a-22824 b-22825)
+                                        (eq? (syntax->datum a-22824) #:key))
+                                      tmp-22820)
                                     #f)
                                 (@apply
-                                  (lambda (a-25572 b-25573)
-                                    (key-25508
-                                      b-25573
-                                      (reverse rreq-25514)
+                                  (lambda (a-22826 b-22827)
+                                    (key-22762
+                                      b-22827
+                                      (reverse rreq-22768)
                                       '()
                                       '()))
-                                  tmp-25566)
-                                (let ((tmp-25576
-                                        ($sc-dispatch args-25513 '(any any))))
-                                  (if (if tmp-25576
+                                  tmp-22820)
+                                (let ((tmp-22830
+                                        ($sc-dispatch args-22767 '(any any))))
+                                  (if (if tmp-22830
                                         (@apply
-                                          (lambda (a-25580 b-25581)
-                                            (eq? (syntax->datum a-25580)
+                                          (lambda (a-22834 b-22835)
+                                            (eq? (syntax->datum a-22834)
                                                  #:rest))
-                                          tmp-25576)
+                                          tmp-22830)
                                         #f)
                                     (@apply
-                                      (lambda (a-25582 b-25583)
-                                        (rest-25509
-                                          b-25583
-                                          (reverse rreq-25514)
+                                      (lambda (a-22836 b-22837)
+                                        (rest-22763
+                                          b-22837
+                                          (reverse rreq-22768)
                                           '()
                                           '()))
-                                      tmp-25576)
-                                    (let ((tmp-25586 (list args-25513)))
+                                      tmp-22830)
+                                    (let ((tmp-22840 (list args-22767)))
                                       (if (@apply
-                                            (lambda (r-25588)
-                                              (if (symbol? r-25588)
+                                            (lambda (r-22842)
+                                              (if (symbol? r-22842)
                                                 #t
-                                                (if (if (vector? r-25588)
+                                                (if (if (vector? r-22842)
                                                       (if (= (vector-length
-                                                               r-25588)
+                                                               r-22842)
                                                              4)
                                                         (eq? (vector-ref
-                                                               r-25588
+                                                               r-22842
                                                                0)
                                                              'syntax-object)
                                                         #f)
                                                       #f)
                                                   (symbol?
-                                                    (vector-ref r-25588 1))
+                                                    (vector-ref r-22842 1))
                                                   #f)))
-                                            tmp-25586)
+                                            tmp-22840)
                                         (@apply
-                                          (lambda (r-25618)
-                                            (rest-25509
-                                              r-25618
-                                              (reverse rreq-25514)
+                                          (lambda (r-22872)
+                                            (rest-22763
+                                              r-22872
+                                              (reverse rreq-22768)
                                               '()
                                               '()))
-                                          tmp-25586)
+                                          tmp-22840)
                                         (syntax-violation
                                           'lambda*
                                           "invalid argument list"
-                                          orig-args-25505
-                                          args-25513)))))))))))))))
-            (opt-25507
-              (lambda (args-25637 req-25638 ropt-25639)
-                (let ((tmp-25641 ($sc-dispatch args-25637 '())))
-                  (if tmp-25641
+                                          orig-args-22759
+                                          args-22767)))))))))))))))
+            (opt-22761
+              (lambda (args-22891 req-22892 ropt-22893)
+                (let ((tmp-22895 ($sc-dispatch args-22891 '())))
+                  (if tmp-22895
                     (@apply
                       (lambda ()
-                        (check-25510
-                          req-25638
-                          (reverse ropt-25639)
+                        (check-22764
+                          req-22892
+                          (reverse ropt-22893)
                           #f
                           '()))
-                      tmp-25641)
-                    (let ((tmp-25647
-                            ($sc-dispatch args-25637 '(any . any))))
-                      (if (if tmp-25647
+                      tmp-22895)
+                    (let ((tmp-22901
+                            ($sc-dispatch args-22891 '(any . any))))
+                      (if (if tmp-22901
                             (@apply
-                              (lambda (a-25651 b-25652)
-                                (if (symbol? a-25651)
+                              (lambda (a-22905 b-22906)
+                                (if (symbol? a-22905)
                                   #t
-                                  (if (if (vector? a-25651)
-                                        (if (= (vector-length a-25651) 4)
-                                          (eq? (vector-ref a-25651 0)
+                                  (if (if (vector? a-22905)
+                                        (if (= (vector-length a-22905) 4)
+                                          (eq? (vector-ref a-22905 0)
                                                'syntax-object)
                                           #f)
                                         #f)
-                                    (symbol? (vector-ref a-25651 1))
+                                    (symbol? (vector-ref a-22905 1))
                                     #f)))
-                              tmp-25647)
+                              tmp-22901)
                             #f)
                         (@apply
-                          (lambda (a-25679 b-25680)
-                            (opt-25507
-                              b-25680
-                              req-25638
-                              (cons (cons a-25679
+                          (lambda (a-22933 b-22934)
+                            (opt-22761
+                              b-22934
+                              req-22892
+                              (cons (cons a-22933
                                           '(#(syntax-object
                                               #f
                                               ((top)
                                                #(ribcage
                                                  #(a b)
                                                  #((top) (top))
-                                                 #("l-*-2404" "l-*-2405"))
+                                                 #("l-*-2402" "l-*-2403"))
                                                #(ribcage () () ())
                                                #(ribcage
                                                  #(args req ropt)
                                                  #((top) (top) (top))
-                                                 #("l-*-2394"
-                                                   "l-*-2395"
-                                                   "l-*-2396"))
+                                                 #("l-*-2392"
+                                                   "l-*-2393"
+                                                   "l-*-2394"))
                                                #(ribcage
                                                  (check rest key opt req)
                                                  ((top)
@@ -6454,15 +7085,15 @@
                                                   (top)
                                                   (top)
                                                   (top))
-                                                 ("l-*-2340"
-                                                  "l-*-2338"
+                                                 ("l-*-2338"
                                                   "l-*-2336"
                                                   "l-*-2334"
-                                                  "l-*-2332"))
+                                                  "l-*-2332"
+                                                  "l-*-2330"))
                                                #(ribcage
                                                  #(orig-args)
                                                  #((top))
-                                                 #("l-*-2331"))
+                                                 #("l-*-2329"))
                                                #(ribcage
                                                  (lambda-var-list
                                                    gen-var
@@ -6891,136 +7522,136 @@
                                                  ((top) (top) (top))
                                                  ("l-*-47" "l-*-46" "l-*-45")))
                                               (hygiene guile))))
-                                    ropt-25639)))
-                          tmp-25647)
-                        (let ((tmp-25681
-                                ($sc-dispatch args-25637 '((any any) . any))))
-                          (if (if tmp-25681
+                                    ropt-22893)))
+                          tmp-22901)
+                        (let ((tmp-22935
+                                ($sc-dispatch args-22891 '((any any) . any))))
+                          (if (if tmp-22935
                                 (@apply
-                                  (lambda (a-25685 init-25686 b-25687)
-                                    (if (symbol? a-25685)
+                                  (lambda (a-22939 init-22940 b-22941)
+                                    (if (symbol? a-22939)
                                       #t
-                                      (if (if (vector? a-25685)
-                                            (if (= (vector-length a-25685) 4)
-                                              (eq? (vector-ref a-25685 0)
+                                      (if (if (vector? a-22939)
+                                            (if (= (vector-length a-22939) 4)
+                                              (eq? (vector-ref a-22939 0)
                                                    'syntax-object)
                                               #f)
                                             #f)
-                                        (symbol? (vector-ref a-25685 1))
+                                        (symbol? (vector-ref a-22939 1))
                                         #f)))
-                                  tmp-25681)
+                                  tmp-22935)
                                 #f)
                             (@apply
-                              (lambda (a-25714 init-25715 b-25716)
-                                (opt-25507
-                                  b-25716
-                                  req-25638
-                                  (cons (list a-25714 init-25715) ropt-25639)))
-                              tmp-25681)
-                            (let ((tmp-25717
-                                    ($sc-dispatch args-25637 '(any . any))))
-                              (if (if tmp-25717
+                              (lambda (a-22968 init-22969 b-22970)
+                                (opt-22761
+                                  b-22970
+                                  req-22892
+                                  (cons (list a-22968 init-22969) ropt-22893)))
+                              tmp-22935)
+                            (let ((tmp-22971
+                                    ($sc-dispatch args-22891 '(any . any))))
+                              (if (if tmp-22971
                                     (@apply
-                                      (lambda (a-25721 b-25722)
-                                        (eq? (syntax->datum a-25721) #:key))
-                                      tmp-25717)
+                                      (lambda (a-22975 b-22976)
+                                        (eq? (syntax->datum a-22975) #:key))
+                                      tmp-22971)
                                     #f)
                                 (@apply
-                                  (lambda (a-25723 b-25724)
-                                    (key-25508
-                                      b-25724
-                                      req-25638
-                                      (reverse ropt-25639)
+                                  (lambda (a-22977 b-22978)
+                                    (key-22762
+                                      b-22978
+                                      req-22892
+                                      (reverse ropt-22893)
                                       '()))
-                                  tmp-25717)
-                                (let ((tmp-25727
-                                        ($sc-dispatch args-25637 '(any any))))
-                                  (if (if tmp-25727
+                                  tmp-22971)
+                                (let ((tmp-22981
+                                        ($sc-dispatch args-22891 '(any any))))
+                                  (if (if tmp-22981
                                         (@apply
-                                          (lambda (a-25731 b-25732)
-                                            (eq? (syntax->datum a-25731)
+                                          (lambda (a-22985 b-22986)
+                                            (eq? (syntax->datum a-22985)
                                                  #:rest))
-                                          tmp-25727)
+                                          tmp-22981)
                                         #f)
                                     (@apply
-                                      (lambda (a-25733 b-25734)
-                                        (rest-25509
-                                          b-25734
-                                          req-25638
-                                          (reverse ropt-25639)
+                                      (lambda (a-22987 b-22988)
+                                        (rest-22763
+                                          b-22988
+                                          req-22892
+                                          (reverse ropt-22893)
                                           '()))
-                                      tmp-25727)
-                                    (let ((tmp-25737 (list args-25637)))
+                                      tmp-22981)
+                                    (let ((tmp-22991 (list args-22891)))
                                       (if (@apply
-                                            (lambda (r-25739)
-                                              (if (symbol? r-25739)
+                                            (lambda (r-22993)
+                                              (if (symbol? r-22993)
                                                 #t
-                                                (if (if (vector? r-25739)
+                                                (if (if (vector? r-22993)
                                                       (if (= (vector-length
-                                                               r-25739)
+                                                               r-22993)
                                                              4)
                                                         (eq? (vector-ref
-                                                               r-25739
+                                                               r-22993
                                                                0)
                                                              'syntax-object)
                                                         #f)
                                                       #f)
                                                   (symbol?
-                                                    (vector-ref r-25739 1))
+                                                    (vector-ref r-22993 1))
                                                   #f)))
-                                            tmp-25737)
+                                            tmp-22991)
                                         (@apply
-                                          (lambda (r-25769)
-                                            (rest-25509
-                                              r-25769
-                                              req-25638
-                                              (reverse ropt-25639)
+                                          (lambda (r-23023)
+                                            (rest-22763
+                                              r-23023
+                                              req-22892
+                                              (reverse ropt-22893)
                                               '()))
-                                          tmp-25737)
+                                          tmp-22991)
                                         (syntax-violation
                                           'lambda*
                                           "invalid optional argument list"
-                                          orig-args-25505
-                                          args-25637)))))))))))))))
-            (key-25508
-              (lambda (args-25788 req-25789 opt-25790 rkey-25791)
-                (let ((tmp-25793 ($sc-dispatch args-25788 '())))
-                  (if tmp-25793
+                                          orig-args-22759
+                                          args-22891)))))))))))))))
+            (key-22762
+              (lambda (args-23042 req-23043 opt-23044 rkey-23045)
+                (let ((tmp-23047 ($sc-dispatch args-23042 '())))
+                  (if tmp-23047
                     (@apply
                       (lambda ()
-                        (check-25510
-                          req-25789
-                          opt-25790
+                        (check-22764
+                          req-23043
+                          opt-23044
                           #f
-                          (cons #f (reverse rkey-25791))))
-                      tmp-25793)
-                    (let ((tmp-25799
-                            ($sc-dispatch args-25788 '(any . any))))
-                      (if (if tmp-25799
+                          (cons #f (reverse rkey-23045))))
+                      tmp-23047)
+                    (let ((tmp-23053
+                            ($sc-dispatch args-23042 '(any . any))))
+                      (if (if tmp-23053
                             (@apply
-                              (lambda (a-25803 b-25804)
-                                (if (symbol? a-25803)
+                              (lambda (a-23057 b-23058)
+                                (if (symbol? a-23057)
                                   #t
-                                  (if (if (vector? a-25803)
-                                        (if (= (vector-length a-25803) 4)
-                                          (eq? (vector-ref a-25803 0)
+                                  (if (if (vector? a-23057)
+                                        (if (= (vector-length a-23057) 4)
+                                          (eq? (vector-ref a-23057 0)
                                                'syntax-object)
                                           #f)
                                         #f)
-                                    (symbol? (vector-ref a-25803 1))
+                                    (symbol? (vector-ref a-23057 1))
                                     #f)))
-                              tmp-25799)
+                              tmp-23053)
                             #f)
                         (@apply
-                          (lambda (a-25831 b-25832)
-                            (let ((tmp-25833
-                                    (symbol->keyword (syntax->datum a-25831))))
-                              (key-25508
-                                b-25832
-                                req-25789
-                                opt-25790
-                                (cons (cons tmp-25833
-                                            (cons a-25831
+                          (lambda (a-23085 b-23086)
+                            (let ((tmp-23087
+                                    (symbol->keyword (syntax->datum a-23085))))
+                              (key-22762
+                                b-23086
+                                req-23043
+                                opt-23044
+                                (cons (cons tmp-23087
+                                            (cons a-23085
                                                   '(#(syntax-object
                                                       #f
                                                       ((top)
@@ -7028,12 +7659,12 @@
                                                        #(ribcage
                                                          #(k)
                                                          #((top))
-                                                         #("l-*-2467"))
+                                                         #("l-*-2465"))
                                                        #(ribcage
                                                          #(a b)
                                                          #((top) (top))
-                                                         #("l-*-2461"
-                                                           "l-*-2462"))
+                                                         #("l-*-2459"
+                                                           "l-*-2460"))
                                                        #(ribcage () () ())
                                                        #(ribcage
                                                          #(args req opt rkey)
@@ -7041,10 +7672,10 @@
                                                            (top)
                                                            (top)
                                                            (top))
-                                                         #("l-*-2450"
-                                                           "l-*-2451"
-                                                           "l-*-2452"
-                                                           "l-*-2453"))
+                                                         #("l-*-2448"
+                                                           "l-*-2449"
+                                                           "l-*-2450"
+                                                           "l-*-2451"))
                                                        #(ribcage
                                                          (check rest
                                                                 key
@@ -7055,15 +7686,15 @@
                                                           (top)
                                                           (top)
                                                           (top))
-                                                         ("l-*-2340"
-                                                          "l-*-2338"
+                                                         ("l-*-2338"
                                                           "l-*-2336"
                                                           "l-*-2334"
-                                                          "l-*-2332"))
+                                                          "l-*-2332"
+                                                          "l-*-2330"))
                                                        #(ribcage
                                                          #(orig-args)
                                                          #((top))
-                                                         #("l-*-2331"))
+                                                         #("l-*-2329"))
                                                        #(ribcage
                                                          (lambda-var-list
                                                            gen-var
@@ -7494,729 +8125,809 @@
                                                           "l-*-46"
                                                           "l-*-45")))
                                                       (hygiene guile)))))
-                                      rkey-25791))))
-                          tmp-25799)
-                        (let ((tmp-25836
-                                ($sc-dispatch args-25788 '((any any) . any))))
-                          (if (if tmp-25836
+                                      rkey-23045))))
+                          tmp-23053)
+                        (let ((tmp-23090
+                                ($sc-dispatch args-23042 '((any any) . any))))
+                          (if (if tmp-23090
                                 (@apply
-                                  (lambda (a-25840 init-25841 b-25842)
-                                    (if (symbol? a-25840)
+                                  (lambda (a-23094 init-23095 b-23096)
+                                    (if (symbol? a-23094)
                                       #t
-                                      (if (if (vector? a-25840)
-                                            (if (= (vector-length a-25840) 4)
-                                              (eq? (vector-ref a-25840 0)
+                                      (if (if (vector? a-23094)
+                                            (if (= (vector-length a-23094) 4)
+                                              (eq? (vector-ref a-23094 0)
                                                    'syntax-object)
                                               #f)
                                             #f)
-                                        (symbol? (vector-ref a-25840 1))
+                                        (symbol? (vector-ref a-23094 1))
                                         #f)))
-                                  tmp-25836)
+                                  tmp-23090)
                                 #f)
                             (@apply
-                              (lambda (a-25869 init-25870 b-25871)
-                                (let ((tmp-25872
+                              (lambda (a-23123 init-23124 b-23125)
+                                (let ((tmp-23126
                                         (symbol->keyword
-                                          (syntax->datum a-25869))))
-                                  (key-25508
-                                    b-25871
-                                    req-25789
-                                    opt-25790
-                                    (cons (list tmp-25872 a-25869 init-25870)
-                                          rkey-25791))))
-                              tmp-25836)
-                            (let ((tmp-25875
+                                          (syntax->datum a-23123))))
+                                  (key-22762
+                                    b-23125
+                                    req-23043
+                                    opt-23044
+                                    (cons (list tmp-23126 a-23123 init-23124)
+                                          rkey-23045))))
+                              tmp-23090)
+                            (let ((tmp-23129
                                     ($sc-dispatch
-                                      args-25788
+                                      args-23042
                                       '((any any any) . any))))
-                              (if (if tmp-25875
+                              (if (if tmp-23129
                                     (@apply
-                                      (lambda (a-25879
-                                               init-25880
-                                               k-25881
-                                               b-25882)
-                                        (if (if (symbol? a-25879)
+                                      (lambda (a-23133
+                                               init-23134
+                                               k-23135
+                                               b-23136)
+                                        (if (if (symbol? a-23133)
                                               #t
-                                              (if (if (vector? a-25879)
+                                              (if (if (vector? a-23133)
                                                     (if (= (vector-length
-                                                             a-25879)
+                                                             a-23133)
                                                            4)
                                                       (eq? (vector-ref
-                                                             a-25879
+                                                             a-23133
                                                              0)
                                                            'syntax-object)
                                                       #f)
                                                     #f)
                                                 (symbol?
-                                                  (vector-ref a-25879 1))
+                                                  (vector-ref a-23133 1))
                                                 #f))
-                                          (keyword? (syntax->datum k-25881))
+                                          (keyword? (syntax->datum k-23135))
                                           #f))
-                                      tmp-25875)
+                                      tmp-23129)
                                     #f)
                                 (@apply
-                                  (lambda (a-25909 init-25910 k-25911 b-25912)
-                                    (key-25508
-                                      b-25912
-                                      req-25789
-                                      opt-25790
-                                      (cons (list k-25911 a-25909 init-25910)
-                                            rkey-25791)))
-                                  tmp-25875)
-                                (let ((tmp-25913
-                                        ($sc-dispatch args-25788 '(any))))
-                                  (if (if tmp-25913
+                                  (lambda (a-23163 init-23164 k-23165 b-23166)
+                                    (key-22762
+                                      b-23166
+                                      req-23043
+                                      opt-23044
+                                      (cons (list k-23165 a-23163 init-23164)
+                                            rkey-23045)))
+                                  tmp-23129)
+                                (let ((tmp-23167
+                                        ($sc-dispatch args-23042 '(any))))
+                                  (if (if tmp-23167
                                         (@apply
-                                          (lambda (aok-25917)
-                                            (eq? (syntax->datum aok-25917)
+                                          (lambda (aok-23171)
+                                            (eq? (syntax->datum aok-23171)
                                                  #:allow-other-keys))
-                                          tmp-25913)
+                                          tmp-23167)
                                         #f)
                                     (@apply
-                                      (lambda (aok-25918)
-                                        (check-25510
-                                          req-25789
-                                          opt-25790
+                                      (lambda (aok-23172)
+                                        (check-22764
+                                          req-23043
+                                          opt-23044
                                           #f
-                                          (cons #t (reverse rkey-25791))))
-                                      tmp-25913)
-                                    (let ((tmp-25921
+                                          (cons #t (reverse rkey-23045))))
+                                      tmp-23167)
+                                    (let ((tmp-23175
                                             ($sc-dispatch
-                                              args-25788
+                                              args-23042
                                               '(any any any))))
-                                      (if (if tmp-25921
+                                      (if (if tmp-23175
                                             (@apply
-                                              (lambda (aok-25925
-                                                       a-25926
-                                                       b-25927)
+                                              (lambda (aok-23179
+                                                       a-23180
+                                                       b-23181)
                                                 (if (eq? (syntax->datum
-                                                           aok-25925)
+                                                           aok-23179)
                                                          #:allow-other-keys)
-                                                  (eq? (syntax->datum a-25926)
+                                                  (eq? (syntax->datum a-23180)
                                                        #:rest)
                                                   #f))
-                                              tmp-25921)
+                                              tmp-23175)
                                             #f)
                                         (@apply
-                                          (lambda (aok-25928 a-25929 b-25930)
-                                            (rest-25509
-                                              b-25930
-                                              req-25789
-                                              opt-25790
-                                              (cons #t (reverse rkey-25791))))
-                                          tmp-25921)
-                                        (let ((tmp-25933
+                                          (lambda (aok-23182 a-23183 b-23184)
+                                            (rest-22763
+                                              b-23184
+                                              req-23043
+                                              opt-23044
+                                              (cons #t (reverse rkey-23045))))
+                                          tmp-23175)
+                                        (let ((tmp-23187
                                                 ($sc-dispatch
-                                                  args-25788
+                                                  args-23042
                                                   '(any . any))))
-                                          (if (if tmp-25933
+                                          (if (if tmp-23187
                                                 (@apply
-                                                  (lambda (aok-25937 r-25938)
+                                                  (lambda (aok-23191 r-23192)
                                                     (if (eq? (syntax->datum
-                                                               aok-25937)
+                                                               aok-23191)
                                                              
#:allow-other-keys)
-                                                      (if (symbol? r-25938)
+                                                      (if (symbol? r-23192)
                                                         #t
                                                         (if (if (vector?
-                                                                  r-25938)
+                                                                  r-23192)
                                                               (if (= 
(vector-length
-                                                                       r-25938)
+                                                                       r-23192)
                                                                      4)
                                                                 (eq? 
(vector-ref
-                                                                       r-25938
+                                                                       r-23192
                                                                        0)
                                                                      
'syntax-object)
                                                                 #f)
                                                               #f)
                                                           (symbol?
                                                             (vector-ref
-                                                              r-25938
+                                                              r-23192
                                                               1))
                                                           #f))
                                                       #f))
-                                                  tmp-25933)
+                                                  tmp-23187)
                                                 #f)
                                             (@apply
-                                              (lambda (aok-25965 r-25966)
-                                                (rest-25509
-                                                  r-25966
-                                                  req-25789
-                                                  opt-25790
+                                              (lambda (aok-23219 r-23220)
+                                                (rest-22763
+                                                  r-23220
+                                                  req-23043
+                                                  opt-23044
                                                   (cons #t
-                                                        (reverse rkey-25791))))
-                                              tmp-25933)
-                                            (let ((tmp-25969
+                                                        (reverse rkey-23045))))
+                                              tmp-23187)
+                                            (let ((tmp-23223
                                                     ($sc-dispatch
-                                                      args-25788
+                                                      args-23042
                                                       '(any any))))
-                                              (if (if tmp-25969
+                                              (if (if tmp-23223
                                                     (@apply
-                                                      (lambda (a-25973 b-25974)
+                                                      (lambda (a-23227 b-23228)
                                                         (eq? (syntax->datum
-                                                               a-25973)
+                                                               a-23227)
                                                              #:rest))
-                                                      tmp-25969)
+                                                      tmp-23223)
                                                     #f)
                                                 (@apply
-                                                  (lambda (a-25975 b-25976)
-                                                    (rest-25509
-                                                      b-25976
-                                                      req-25789
-                                                      opt-25790
+                                                  (lambda (a-23229 b-23230)
+                                                    (rest-22763
+                                                      b-23230
+                                                      req-23043
+                                                      opt-23044
                                                       (cons #f
                                                             (reverse
-                                                              rkey-25791))))
-                                                  tmp-25969)
-                                                (let ((tmp-25979
-                                                        (list args-25788)))
+                                                              rkey-23045))))
+                                                  tmp-23223)
+                                                (let ((tmp-23233
+                                                        (list args-23042)))
                                                   (if (@apply
-                                                        (lambda (r-25981)
-                                                          (if (symbol? r-25981)
+                                                        (lambda (r-23235)
+                                                          (if (symbol? r-23235)
                                                             #t
                                                             (if (if (vector?
-                                                                      r-25981)
+                                                                      r-23235)
                                                                   (if (= 
(vector-length
-                                                                           
r-25981)
+                                                                           
r-23235)
                                                                          4)
                                                                     (eq? 
(vector-ref
-                                                                           
r-25981
+                                                                           
r-23235
                                                                            0)
                                                                          
'syntax-object)
                                                                     #f)
                                                                   #f)
                                                               (symbol?
                                                                 (vector-ref
-                                                                  r-25981
+                                                                  r-23235
                                                                   1))
                                                               #f)))
-                                                        tmp-25979)
+                                                        tmp-23233)
                                                     (@apply
-                                                      (lambda (r-26011)
-                                                        (rest-25509
-                                                          r-26011
-                                                          req-25789
-                                                          opt-25790
+                                                      (lambda (r-23265)
+                                                        (rest-22763
+                                                          r-23265
+                                                          req-23043
+                                                          opt-23044
                                                           (cons #f
                                                                 (reverse
-                                                                  
rkey-25791))))
-                                                      tmp-25979)
+                                                                  
rkey-23045))))
+                                                      tmp-23233)
                                                     (syntax-violation
                                                       'lambda*
                                                       "invalid keyword 
argument list"
-                                                      orig-args-25505
-                                                      
args-25788)))))))))))))))))))))
-            (rest-25509
-              (lambda (args-26039 req-26040 opt-26041 kw-26042)
-                (let ((tmp-26044 (list args-26039)))
+                                                      orig-args-22759
+                                                      
args-23042)))))))))))))))))))))
+            (rest-22763
+              (lambda (args-23293 req-23294 opt-23295 kw-23296)
+                (let ((tmp-23298 (list args-23293)))
                   (if (@apply
-                        (lambda (r-26046)
-                          (if (symbol? r-26046)
+                        (lambda (r-23300)
+                          (if (symbol? r-23300)
                             #t
-                            (if (if (vector? r-26046)
-                                  (if (= (vector-length r-26046) 4)
-                                    (eq? (vector-ref r-26046 0) 'syntax-object)
+                            (if (if (vector? r-23300)
+                                  (if (= (vector-length r-23300) 4)
+                                    (eq? (vector-ref r-23300 0) 'syntax-object)
                                     #f)
                                   #f)
-                              (symbol? (vector-ref r-26046 1))
+                              (symbol? (vector-ref r-23300 1))
                               #f)))
-                        tmp-26044)
+                        tmp-23298)
                     (@apply
-                      (lambda (r-26076)
-                        (check-25510
-                          req-26040
-                          opt-26041
-                          r-26076
-                          kw-26042))
-                      tmp-26044)
+                      (lambda (r-23330)
+                        (check-22764
+                          req-23294
+                          opt-23295
+                          r-23330
+                          kw-23296))
+                      tmp-23298)
                     (syntax-violation
                       'lambda*
                       "invalid rest argument"
-                      orig-args-25505
-                      args-26039)))))
-            (check-25510
-              (lambda (req-26080 opt-26081 rest-26082 kw-26083)
-                (if (distinct-bound-ids?-4322
+                      orig-args-22759
+                      args-23293)))))
+            (check-22764
+              (lambda (req-23334 opt-23335 rest-23336 kw-23337)
+                (if (distinct-bound-ids?-4288
                       (append
-                        req-26080
-                        (map car opt-26081)
-                        (if rest-26082 (list rest-26082) '())
-                        (if (pair? kw-26083)
-                          (map cadr (cdr kw-26083))
+                        req-23334
+                        (map car opt-23335)
+                        (if rest-23336 (list rest-23336) '())
+                        (if (pair? kw-23337)
+                          (map cadr (cdr kw-23337))
                           '())))
-                  (values req-26080 opt-26081 rest-26082 kw-26083)
+                  (values req-23334 opt-23335 rest-23336 kw-23337)
                   (syntax-violation
                     'lambda*
                     "duplicate identifier in argument list"
-                    orig-args-25505)))))
-           (req-25506 orig-args-25505 '()))))
-     (expand-lambda-case-4343
-       (lambda (e-26199
-                r-26200
-                w-26201
-                s-26202
-                mod-26203
-                get-formals-26204
-                clauses-26205)
+                    orig-args-22759)))))
+           (req-22760 orig-args-22759 '()))))
+     (expand-lambda-case-4309
+       (lambda (e-23453
+                r-23454
+                w-23455
+                s-23456
+                mod-23457
+                get-formals-23458
+                clauses-23459)
          (letrec*
-           ((parse-req-26206
-              (lambda (req-26337
-                       opt-26338
-                       rest-26339
-                       kw-26340
-                       body-26341)
-                (let ((vars-26342 (map gen-var-4345 req-26337))
-                      (labels-26343 (gen-labels-4298 req-26337)))
-                  (let ((r*-26344
-                          (extend-var-env-4290
-                            labels-26343
-                            vars-26342
-                            r-26200))
-                        (w*-26345
-                          (make-binding-wrap-4309
-                            req-26337
-                            labels-26343
-                            w-26201)))
-                    (parse-opt-26207
-                      (map syntax->datum req-26337)
-                      opt-26338
-                      rest-26339
-                      kw-26340
-                      body-26341
-                      (reverse vars-26342)
-                      r*-26344
-                      w*-26345
+           ((parse-req-23460
+              (lambda (req-23591
+                       opt-23592
+                       rest-23593
+                       kw-23594
+                       body-23595)
+                (let ((vars-23596 (map gen-var-4311 req-23591))
+                      (labels-23597 (gen-labels-4264 req-23591)))
+                  (let ((r*-23598
+                          (extend-var-env-4256
+                            labels-23597
+                            vars-23596
+                            r-23454))
+                        (w*-23599
+                          (make-binding-wrap-4275
+                            req-23591
+                            labels-23597
+                            w-23455)))
+                    (parse-opt-23461
+                      (map syntax->datum req-23591)
+                      opt-23592
+                      rest-23593
+                      kw-23594
+                      body-23595
+                      (reverse vars-23596)
+                      r*-23598
+                      w*-23599
                       '()
                       '())))))
-            (parse-opt-26207
-              (lambda (req-26531
-                       opt-26532
-                       rest-26533
-                       kw-26534
-                       body-26535
-                       vars-26536
-                       r*-26537
-                       w*-26538
-                       out-26539
-                       inits-26540)
-                (if (pair? opt-26532)
-                  (let ((tmp-26541 (car opt-26532)))
-                    (let ((tmp-26542 ($sc-dispatch tmp-26541 '(any any))))
-                      (if tmp-26542
+            (parse-opt-23461
+              (lambda (req-23785
+                       opt-23786
+                       rest-23787
+                       kw-23788
+                       body-23789
+                       vars-23790
+                       r*-23791
+                       w*-23792
+                       out-23793
+                       inits-23794)
+                (if (pair? opt-23786)
+                  (let ((tmp-23795 (car opt-23786)))
+                    (let ((tmp-23796 ($sc-dispatch tmp-23795 '(any any))))
+                      (if tmp-23796
                         (@apply
-                          (lambda (id-26544 i-26545)
-                            (let ((v-26546
-                                    (let ((id-26554
-                                            (if (if (vector? id-26544)
+                          (lambda (id-23798 i-23799)
+                            (let ((v-23800
+                                    (let ((id-23808
+                                            (if (if (vector? id-23798)
                                                   (if (= (vector-length
-                                                           id-26544)
+                                                           id-23798)
                                                          4)
                                                     (eq? (vector-ref
-                                                           id-26544
+                                                           id-23798
                                                            0)
                                                          'syntax-object)
                                                     #f)
                                                   #f)
-                                              (vector-ref id-26544 1)
-                                              id-26544)))
+                                              (vector-ref id-23798 1)
+                                              id-23798)))
                                       (gensym
                                         (string-append
-                                          (symbol->string id-26554)
+                                          (symbol->string id-23808)
                                           "-")))))
-                              (let ((l-26547 (gen-labels-4298 (list v-26546))))
-                                (let ((r**-26548
-                                        (extend-var-env-4290
-                                          l-26547
-                                          (list v-26546)
-                                          r*-26537)))
-                                  (let ((w**-26549
-                                          (make-binding-wrap-4309
-                                            (list id-26544)
-                                            l-26547
-                                            w*-26538)))
-                                    (parse-opt-26207
-                                      req-26531
-                                      (cdr opt-26532)
-                                      rest-26533
-                                      kw-26534
-                                      body-26535
-                                      (cons v-26546 vars-26536)
-                                      r**-26548
-                                      w**-26549
-                                      (cons (syntax->datum id-26544) out-26539)
-                                      (cons (expand-4331
-                                              i-26545
-                                              r*-26537
-                                              w*-26538
-                                              mod-26203)
-                                            inits-26540)))))))
-                          tmp-26542)
+                              (let ((l-23801 (gen-labels-4264 (list v-23800))))
+                                (let ((r**-23802
+                                        (extend-var-env-4256
+                                          l-23801
+                                          (list v-23800)
+                                          r*-23791)))
+                                  (let ((w**-23803
+                                          (make-binding-wrap-4275
+                                            (list id-23798)
+                                            l-23801
+                                            w*-23792)))
+                                    (parse-opt-23461
+                                      req-23785
+                                      (cdr opt-23786)
+                                      rest-23787
+                                      kw-23788
+                                      body-23789
+                                      (cons v-23800 vars-23790)
+                                      r**-23802
+                                      w**-23803
+                                      (cons (syntax->datum id-23798) out-23793)
+                                      (cons (call-with-values
+                                              (lambda ()
+                                                (syntax-type-4296
+                                                  i-23799
+                                                  r*-23791
+                                                  w*-23792
+                                                  (let ((props-23882
+                                                          (source-properties
+                                                            (if (if (vector?
+                                                                      i-23799)
+                                                                  (if (= 
(vector-length
+                                                                           
i-23799)
+                                                                         4)
+                                                                    (eq? 
(vector-ref
+                                                                           
i-23799
+                                                                           0)
+                                                                         
'syntax-object)
+                                                                    #f)
+                                                                  #f)
+                                                              (vector-ref
+                                                                i-23799
+                                                                1)
+                                                              i-23799))))
+                                                    (if (pair? props-23882)
+                                                      props-23882
+                                                      #f))
+                                                  #f
+                                                  mod-23457
+                                                  #f))
+                                              (lambda (type-23915
+                                                       value-23916
+                                                       form-23917
+                                                       e-23918
+                                                       w-23919
+                                                       s-23920
+                                                       mod-23921)
+                                                (expand-expr-4298
+                                                  type-23915
+                                                  value-23916
+                                                  form-23917
+                                                  e-23918
+                                                  r*-23791
+                                                  w-23919
+                                                  s-23920
+                                                  mod-23921)))
+                                            inits-23794)))))))
+                          tmp-23796)
                         (syntax-violation
                           #f
                           "source expression failed to match any pattern"
-                          tmp-26541))))
-                  (if rest-26533
-                    (let ((v-26792
-                            (let ((id-26802
-                                    (if (if (vector? rest-26533)
-                                          (if (= (vector-length rest-26533) 4)
-                                            (eq? (vector-ref rest-26533 0)
+                          tmp-23795))))
+                  (if rest-23787
+                    (let ((v-24035
+                            (let ((id-24045
+                                    (if (if (vector? rest-23787)
+                                          (if (= (vector-length rest-23787) 4)
+                                            (eq? (vector-ref rest-23787 0)
                                                  'syntax-object)
                                             #f)
                                           #f)
-                                      (vector-ref rest-26533 1)
-                                      rest-26533)))
+                                      (vector-ref rest-23787 1)
+                                      rest-23787)))
                               (gensym
                                 (string-append
-                                  (symbol->string id-26802)
+                                  (symbol->string id-24045)
                                   "-")))))
-                      (let ((l-26793 (gen-labels-4298 (list v-26792))))
-                        (let ((r*-26794
-                                (extend-var-env-4290
-                                  l-26793
-                                  (list v-26792)
-                                  r*-26537)))
-                          (let ((w*-26795
-                                  (make-binding-wrap-4309
-                                    (list rest-26533)
-                                    l-26793
-                                    w*-26538)))
-                            (parse-kw-26208
-                              req-26531
-                              (if (pair? out-26539) (reverse out-26539) #f)
-                              (syntax->datum rest-26533)
-                              (if (pair? kw-26534) (cdr kw-26534) kw-26534)
-                              body-26535
-                              (cons v-26792 vars-26536)
-                              r*-26794
-                              w*-26795
-                              (if (pair? kw-26534) (car kw-26534) #f)
+                      (let ((l-24036 (gen-labels-4264 (list v-24035))))
+                        (let ((r*-24037
+                                (extend-var-env-4256
+                                  l-24036
+                                  (list v-24035)
+                                  r*-23791)))
+                          (let ((w*-24038
+                                  (make-binding-wrap-4275
+                                    (list rest-23787)
+                                    l-24036
+                                    w*-23792)))
+                            (parse-kw-23462
+                              req-23785
+                              (if (pair? out-23793) (reverse out-23793) #f)
+                              (syntax->datum rest-23787)
+                              (if (pair? kw-23788) (cdr kw-23788) kw-23788)
+                              body-23789
+                              (cons v-24035 vars-23790)
+                              r*-24037
+                              w*-24038
+                              (if (pair? kw-23788) (car kw-23788) #f)
                               '()
-                              inits-26540)))))
-                    (parse-kw-26208
-                      req-26531
-                      (if (pair? out-26539) (reverse out-26539) #f)
+                              inits-23794)))))
+                    (parse-kw-23462
+                      req-23785
+                      (if (pair? out-23793) (reverse out-23793) #f)
                       #f
-                      (if (pair? kw-26534) (cdr kw-26534) kw-26534)
-                      body-26535
-                      vars-26536
-                      r*-26537
-                      w*-26538
-                      (if (pair? kw-26534) (car kw-26534) #f)
+                      (if (pair? kw-23788) (cdr kw-23788) kw-23788)
+                      body-23789
+                      vars-23790
+                      r*-23791
+                      w*-23792
+                      (if (pair? kw-23788) (car kw-23788) #f)
                       '()
-                      inits-26540)))))
-            (parse-kw-26208
-              (lambda (req-26973
-                       opt-26974
-                       rest-26975
-                       kw-26976
-                       body-26977
-                       vars-26978
-                       r*-26979
-                       w*-26980
-                       aok-26981
-                       out-26982
-                       inits-26983)
-                (if (pair? kw-26976)
-                  (let ((tmp-26984 (car kw-26976)))
-                    (let ((tmp-26985
-                            ($sc-dispatch tmp-26984 '(any any any))))
-                      (if tmp-26985
+                      inits-23794)))))
+            (parse-kw-23462
+              (lambda (req-24216
+                       opt-24217
+                       rest-24218
+                       kw-24219
+                       body-24220
+                       vars-24221
+                       r*-24222
+                       w*-24223
+                       aok-24224
+                       out-24225
+                       inits-24226)
+                (if (pair? kw-24219)
+                  (let ((tmp-24227 (car kw-24219)))
+                    (let ((tmp-24228
+                            ($sc-dispatch tmp-24227 '(any any any))))
+                      (if tmp-24228
                         (@apply
-                          (lambda (k-26987 id-26988 i-26989)
-                            (let ((v-26990
-                                    (let ((id-26998
-                                            (if (if (vector? id-26988)
+                          (lambda (k-24230 id-24231 i-24232)
+                            (let ((v-24233
+                                    (let ((id-24241
+                                            (if (if (vector? id-24231)
                                                   (if (= (vector-length
-                                                           id-26988)
+                                                           id-24231)
                                                          4)
                                                     (eq? (vector-ref
-                                                           id-26988
+                                                           id-24231
                                                            0)
                                                          'syntax-object)
                                                     #f)
                                                   #f)
-                                              (vector-ref id-26988 1)
-                                              id-26988)))
+                                              (vector-ref id-24231 1)
+                                              id-24231)))
                                       (gensym
                                         (string-append
-                                          (symbol->string id-26998)
+                                          (symbol->string id-24241)
                                           "-")))))
-                              (let ((l-26991 (gen-labels-4298 (list v-26990))))
-                                (let ((r**-26992
-                                        (extend-var-env-4290
-                                          l-26991
-                                          (list v-26990)
-                                          r*-26979)))
-                                  (let ((w**-26993
-                                          (make-binding-wrap-4309
-                                            (list id-26988)
-                                            l-26991
-                                            w*-26980)))
-                                    (parse-kw-26208
-                                      req-26973
-                                      opt-26974
-                                      rest-26975
-                                      (cdr kw-26976)
-                                      body-26977
-                                      (cons v-26990 vars-26978)
-                                      r**-26992
-                                      w**-26993
-                                      aok-26981
-                                      (cons (list (syntax->datum k-26987)
-                                                  (syntax->datum id-26988)
-                                                  v-26990)
-                                            out-26982)
-                                      (cons (expand-4331
-                                              i-26989
-                                              r*-26979
-                                              w*-26980
-                                              mod-26203)
-                                            inits-26983)))))))
-                          tmp-26985)
+                              (let ((l-24234 (gen-labels-4264 (list v-24233))))
+                                (let ((r**-24235
+                                        (extend-var-env-4256
+                                          l-24234
+                                          (list v-24233)
+                                          r*-24222)))
+                                  (let ((w**-24236
+                                          (make-binding-wrap-4275
+                                            (list id-24231)
+                                            l-24234
+                                            w*-24223)))
+                                    (parse-kw-23462
+                                      req-24216
+                                      opt-24217
+                                      rest-24218
+                                      (cdr kw-24219)
+                                      body-24220
+                                      (cons v-24233 vars-24221)
+                                      r**-24235
+                                      w**-24236
+                                      aok-24224
+                                      (cons (list (syntax->datum k-24230)
+                                                  (syntax->datum id-24231)
+                                                  v-24233)
+                                            out-24225)
+                                      (cons (call-with-values
+                                              (lambda ()
+                                                (syntax-type-4296
+                                                  i-24232
+                                                  r*-24222
+                                                  w*-24223
+                                                  (let ((props-24315
+                                                          (source-properties
+                                                            (if (if (vector?
+                                                                      i-24232)
+                                                                  (if (= 
(vector-length
+                                                                           
i-24232)
+                                                                         4)
+                                                                    (eq? 
(vector-ref
+                                                                           
i-24232
+                                                                           0)
+                                                                         
'syntax-object)
+                                                                    #f)
+                                                                  #f)
+                                                              (vector-ref
+                                                                i-24232
+                                                                1)
+                                                              i-24232))))
+                                                    (if (pair? props-24315)
+                                                      props-24315
+                                                      #f))
+                                                  #f
+                                                  mod-23457
+                                                  #f))
+                                              (lambda (type-24348
+                                                       value-24349
+                                                       form-24350
+                                                       e-24351
+                                                       w-24352
+                                                       s-24353
+                                                       mod-24354)
+                                                (expand-expr-4298
+                                                  type-24348
+                                                  value-24349
+                                                  form-24350
+                                                  e-24351
+                                                  r*-24222
+                                                  w-24352
+                                                  s-24353
+                                                  mod-24354)))
+                                            inits-24226)))))))
+                          tmp-24228)
                         (syntax-violation
                           #f
                           "source expression failed to match any pattern"
-                          tmp-26984))))
-                  (parse-body-26209
-                    req-26973
-                    opt-26974
-                    rest-26975
-                    (if (if aok-26981 aok-26981 (pair? out-26982))
-                      (cons aok-26981 (reverse out-26982))
+                          tmp-24227))))
+                  (parse-body-23463
+                    req-24216
+                    opt-24217
+                    rest-24218
+                    (if (if aok-24224 aok-24224 (pair? out-24225))
+                      (cons aok-24224 (reverse out-24225))
                       #f)
-                    body-26977
-                    (reverse vars-26978)
-                    r*-26979
-                    w*-26980
-                    (reverse inits-26983)
+                    body-24220
+                    (reverse vars-24221)
+                    r*-24222
+                    w*-24223
+                    (reverse inits-24226)
                     '()))))
-            (parse-body-26209
-              (lambda (req-27245
-                       opt-27246
-                       rest-27247
-                       kw-27248
-                       body-27249
-                       vars-27250
-                       r*-27251
-                       w*-27252
-                       inits-27253
-                       meta-27254)
-                (let ((tmp-27256
-                        ($sc-dispatch body-27249 '(any any . each-any))))
-                  (if (if tmp-27256
+            (parse-body-23463
+              (lambda (req-24477
+                       opt-24478
+                       rest-24479
+                       kw-24480
+                       body-24481
+                       vars-24482
+                       r*-24483
+                       w*-24484
+                       inits-24485
+                       meta-24486)
+                (let ((tmp-24488
+                        ($sc-dispatch body-24481 '(any any . each-any))))
+                  (if (if tmp-24488
                         (@apply
-                          (lambda (docstring-27260 e1-27261 e2-27262)
-                            (string? (syntax->datum docstring-27260)))
-                          tmp-27256)
+                          (lambda (docstring-24492 e1-24493 e2-24494)
+                            (string? (syntax->datum docstring-24492)))
+                          tmp-24488)
                         #f)
                     (@apply
-                      (lambda (docstring-27263 e1-27264 e2-27265)
-                        (parse-body-26209
-                          req-27245
-                          opt-27246
-                          rest-27247
-                          kw-27248
-                          (cons e1-27264 e2-27265)
-                          vars-27250
-                          r*-27251
-                          w*-27252
-                          inits-27253
+                      (lambda (docstring-24495 e1-24496 e2-24497)
+                        (parse-body-23463
+                          req-24477
+                          opt-24478
+                          rest-24479
+                          kw-24480
+                          (cons e1-24496 e2-24497)
+                          vars-24482
+                          r*-24483
+                          w*-24484
+                          inits-24485
                           (append
-                            meta-27254
+                            meta-24486
                             (list (cons 'documentation
-                                        (syntax->datum docstring-27263))))))
-                      tmp-27256)
-                    (let ((tmp-27266
+                                        (syntax->datum docstring-24495))))))
+                      tmp-24488)
+                    (let ((tmp-24498
                             ($sc-dispatch
-                              body-27249
+                              body-24481
                               '(#(vector #(each (any . any)))
                                 any
                                 .
                                 each-any))))
-                      (if tmp-27266
+                      (if tmp-24498
                         (@apply
-                          (lambda (k-27270 v-27271 e1-27272 e2-27273)
-                            (parse-body-26209
-                              req-27245
-                              opt-27246
-                              rest-27247
-                              kw-27248
-                              (cons e1-27272 e2-27273)
-                              vars-27250
-                              r*-27251
-                              w*-27252
-                              inits-27253
+                          (lambda (k-24502 v-24503 e1-24504 e2-24505)
+                            (parse-body-23463
+                              req-24477
+                              opt-24478
+                              rest-24479
+                              kw-24480
+                              (cons e1-24504 e2-24505)
+                              vars-24482
+                              r*-24483
+                              w*-24484
+                              inits-24485
                               (append
-                                meta-27254
-                                (syntax->datum (map cons k-27270 v-27271)))))
-                          tmp-27266)
-                        (let ((tmp-27274
-                                ($sc-dispatch body-27249 '(any . each-any))))
-                          (if tmp-27274
+                                meta-24486
+                                (syntax->datum (map cons k-24502 v-24503)))))
+                          tmp-24498)
+                        (let ((tmp-24506
+                                ($sc-dispatch body-24481 '(any . each-any))))
+                          (if tmp-24506
                             (@apply
-                              (lambda (e1-27278 e2-27279)
+                              (lambda (e1-24510 e2-24511)
                                 (values
-                                  meta-27254
-                                  req-27245
-                                  opt-27246
-                                  rest-27247
-                                  kw-27248
-                                  inits-27253
-                                  vars-27250
-                                  (expand-body-4335
-                                    (cons e1-27278 e2-27279)
-                                    (wrap-4324
+                                  meta-24486
+                                  req-24477
+                                  opt-24478
+                                  rest-24479
+                                  kw-24480
+                                  inits-24485
+                                  vars-24482
+                                  (expand-body-4301
+                                    (cons e1-24510 e2-24511)
+                                    (wrap-4290
                                       (begin
-                                        (if (if s-26202
+                                        (if (if s-23456
                                               (supports-source-properties?
-                                                e-26199)
+                                                e-23453)
                                               #f)
                                           (set-source-properties!
-                                            e-26199
-                                            s-26202))
-                                        e-26199)
-                                      w-26201
-                                      mod-26203)
-                                    r*-27251
-                                    w*-27252
-                                    mod-26203)))
-                              tmp-27274)
+                                            e-23453
+                                            s-23456))
+                                        e-23453)
+                                      w-23455
+                                      mod-23457)
+                                    r*-24483
+                                    w*-24484
+                                    mod-23457)))
+                              tmp-24506)
                             (syntax-violation
                               #f
                               "source expression failed to match any pattern"
-                              body-27249))))))))))
-           (let ((tmp-26211 ($sc-dispatch clauses-26205 '())))
-             (if tmp-26211
-               (@apply (lambda () (values '() #f)) tmp-26211)
-               (let ((tmp-26215
+                              body-24481))))))))))
+           (let ((tmp-23465 ($sc-dispatch clauses-23459 '())))
+             (if tmp-23465
+               (@apply (lambda () (values '() #f)) tmp-23465)
+               (let ((tmp-23469
                        ($sc-dispatch
-                         clauses-26205
+                         clauses-23459
                          '((any any . each-any)
                            .
                            #(each (any any . each-any))))))
-                 (if tmp-26215
+                 (if tmp-23469
                    (@apply
-                     (lambda (args-26219
-                              e1-26220
-                              e2-26221
-                              args*-26222
-                              e1*-26223
-                              e2*-26224)
+                     (lambda (args-23473
+                              e1-23474
+                              e2-23475
+                              args*-23476
+                              e1*-23477
+                              e2*-23478)
                        (call-with-values
-                         (lambda () (get-formals-26204 args-26219))
-                         (lambda (req-26225 opt-26226 rest-26227 kw-26228)
+                         (lambda () (get-formals-23458 args-23473))
+                         (lambda (req-23479 opt-23480 rest-23481 kw-23482)
                            (call-with-values
                              (lambda ()
-                               (parse-req-26206
-                                 req-26225
-                                 opt-26226
-                                 rest-26227
-                                 kw-26228
-                                 (cons e1-26220 e2-26221)))
-                             (lambda (meta-26293
-                                      req-26294
-                                      opt-26295
-                                      rest-26296
-                                      kw-26297
-                                      inits-26298
-                                      vars-26299
-                                      body-26300)
+                               (parse-req-23460
+                                 req-23479
+                                 opt-23480
+                                 rest-23481
+                                 kw-23482
+                                 (cons e1-23474 e2-23475)))
+                             (lambda (meta-23547
+                                      req-23548
+                                      opt-23549
+                                      rest-23550
+                                      kw-23551
+                                      inits-23552
+                                      vars-23553
+                                      body-23554)
                                (call-with-values
                                  (lambda ()
-                                   (expand-lambda-case-4343
-                                     e-26199
-                                     r-26200
-                                     w-26201
-                                     s-26202
-                                     mod-26203
-                                     get-formals-26204
-                                     (map (lambda (tmp-2802-26301
-                                                   tmp-2801-26302
-                                                   tmp-2800-26303)
-                                            (cons tmp-2800-26303
-                                                  (cons tmp-2801-26302
-                                                        tmp-2802-26301)))
-                                          e2*-26224
-                                          e1*-26223
-                                          args*-26222)))
-                                 (lambda (meta*-26304 else*-26305)
+                                   (expand-lambda-case-4309
+                                     e-23453
+                                     r-23454
+                                     w-23455
+                                     s-23456
+                                     mod-23457
+                                     get-formals-23458
+                                     (map (lambda (tmp-2800-23555
+                                                   tmp-2799-23556
+                                                   tmp-2798-23557)
+                                            (cons tmp-2798-23557
+                                                  (cons tmp-2799-23556
+                                                        tmp-2800-23555)))
+                                          e2*-23478
+                                          e1*-23477
+                                          args*-23476)))
+                                 (lambda (meta*-23558 else*-23559)
                                    (values
-                                     (append meta-26293 meta*-26304)
+                                     (append meta-23547 meta*-23558)
                                      (make-struct/no-tail
                                        (vector-ref %expanded-vtables 14)
-                                       s-26202
-                                       req-26294
-                                       opt-26295
-                                       rest-26296
-                                       kw-26297
-                                       inits-26298
-                                       vars-26299
-                                       body-26300
-                                       else*-26305)))))))))
-                     tmp-26215)
+                                       s-23456
+                                       req-23548
+                                       opt-23549
+                                       rest-23550
+                                       kw-23551
+                                       inits-23552
+                                       vars-23553
+                                       body-23554
+                                       else*-23559)))))))))
+                     tmp-23469)
                    (syntax-violation
                      #f
                      "source expression failed to match any pattern"
-                     clauses-26205))))))))
-     (strip-4344
-       (lambda (x-27316 w-27317)
-         (if (memq 'top (car w-27317))
-           x-27316
+                     clauses-23459))))))))
+     (strip-4310
+       (lambda (x-24548 w-24549)
+         (if (memq 'top (car w-24549))
+           x-24548
            (letrec*
-             ((f-27318
-                (lambda (x-27321)
-                  (if (if (vector? x-27321)
-                        (if (= (vector-length x-27321) 4)
-                          (eq? (vector-ref x-27321 0) 'syntax-object)
+             ((f-24550
+                (lambda (x-24553)
+                  (if (if (vector? x-24553)
+                        (if (= (vector-length x-24553) 4)
+                          (eq? (vector-ref x-24553 0) 'syntax-object)
                           #f)
                         #f)
-                    (strip-4344
-                      (vector-ref x-27321 1)
-                      (vector-ref x-27321 2))
-                    (if (pair? x-27321)
-                      (let ((a-27340 (f-27318 (car x-27321)))
-                            (d-27341 (f-27318 (cdr x-27321))))
-                        (if (if (eq? a-27340 (car x-27321))
-                              (eq? d-27341 (cdr x-27321))
+                    (strip-4310
+                      (vector-ref x-24553 1)
+                      (vector-ref x-24553 2))
+                    (if (pair? x-24553)
+                      (let ((a-24572 (f-24550 (car x-24553)))
+                            (d-24573 (f-24550 (cdr x-24553))))
+                        (if (if (eq? a-24572 (car x-24553))
+                              (eq? d-24573 (cdr x-24553))
                               #f)
-                          x-27321
-                          (cons a-27340 d-27341)))
-                      (if (vector? x-27321)
-                        (let ((old-27344 (vector->list x-27321)))
-                          (let ((new-27345 (map f-27318 old-27344)))
+                          x-24553
+                          (cons a-24572 d-24573)))
+                      (if (vector? x-24553)
+                        (let ((old-24576 (vector->list x-24553)))
+                          (let ((new-24577 (map f-24550 old-24576)))
                             (letrec*
-                              ((lp-27346
-                                 (lambda (l1-27422 l2-27423)
-                                   (if (null? l1-27422)
-                                     x-27321
-                                     (if (eq? (car l1-27422) (car l2-27423))
-                                       (lp-27346 (cdr l1-27422) (cdr l2-27423))
-                                       (list->vector new-27345))))))
-                              (lp-27346 old-27344 new-27345))))
-                        x-27321))))))
-             (f-27318 x-27316)))))
-     (gen-var-4345
-       (lambda (id-26349)
-         (let ((id-26350
-                 (if (if (vector? id-26349)
-                       (if (= (vector-length id-26349) 4)
-                         (eq? (vector-ref id-26349 0) 'syntax-object)
+                              ((lp-24578
+                                 (lambda (l1-24654 l2-24655)
+                                   (if (null? l1-24654)
+                                     x-24553
+                                     (if (eq? (car l1-24654) (car l2-24655))
+                                       (lp-24578 (cdr l1-24654) (cdr l2-24655))
+                                       (list->vector new-24577))))))
+                              (lp-24578 old-24576 new-24577))))
+                        x-24553))))))
+             (f-24550 x-24548)))))
+     (gen-var-4311
+       (lambda (id-23603)
+         (let ((id-23604
+                 (if (if (vector? id-23603)
+                       (if (= (vector-length id-23603) 4)
+                         (eq? (vector-ref id-23603 0) 'syntax-object)
                          #f)
                        #f)
-                   (vector-ref id-26349 1)
-                   id-26349)))
+                   (vector-ref id-23603 1)
+                   id-23603)))
            (gensym
-             (string-append (symbol->string id-26350) "-"))))))
+             (string-append (symbol->string id-23604) "-"))))))
     (begin
-      (set! session-id-4256
-        (let ((v-15685
+      (set! session-id-4222
+        (let ((v-14702
                 (module-variable
                   (current-module)
                   'syntax-session-id)))
-          (lambda () ((variable-ref v-15685)))))
-      (set! transformer-environment-4317
+          (lambda () ((variable-ref v-14702)))))
+      (set! transformer-environment-4283
         (make-fluid
-          (lambda (k-14717)
+          (lambda (k-13734)
             (error "called outside the dynamic extent of a syntax 
transformer"))))
       (module-define!
         (current-module)
@@ -8232,11466 +8943,10748 @@
           'let-syntax
           'local-syntax
           #f))
-      (global-extend-4293
+      (global-extend-4259
         'core
         'syntax-parameterize
-        (lambda (e-4466 r-4467 w-4468 s-4469 mod-4470)
-          (let ((tmp-4472
+        (lambda (e-4430 r-4431 w-4432 s-4433 mod-4434)
+          (let ((tmp-4436
                   ($sc-dispatch
-                    e-4466
+                    e-4430
                     '(_ #(each (any any)) any . each-any))))
-            (if (if tmp-4472
+            (if (if tmp-4436
                   (@apply
-                    (lambda (var-4476 val-4477 e1-4478 e2-4479)
-                      (valid-bound-ids?-4321 var-4476))
-                    tmp-4472)
+                    (lambda (var-4438 val-4439 e1-4440 e2-4441)
+                      (valid-bound-ids?-4287 var-4438))
+                    tmp-4436)
                   #f)
               (@apply
-                (lambda (var-4557 val-4558 e1-4559 e2-4560)
-                  (let ((names-4561
-                          (map (lambda (x-4611)
-                                 (id-var-name-4314 x-4611 w-4468))
-                               var-4557)))
+                (lambda (var-4519 val-4520 e1-4521 e2-4522)
+                  (let ((names-4523
+                          (map (lambda (x-4573)
+                                 (id-var-name-4280 x-4573 w-4432))
+                               var-4519)))
                     (begin
                       (for-each
-                        (lambda (id-4562 n-4563)
-                          (let ((key-4564
-                                  (car (let ((t-4571 (assq n-4563 r-4467)))
-                                         (if t-4571
-                                           (cdr t-4571)
-                                           (if (symbol? n-4563)
-                                             (let ((t-4576
-                                                     
(get-global-definition-hook-4258
-                                                       n-4563
-                                                       mod-4470)))
-                                               (if t-4576 t-4576 '(global)))
+                        (lambda (id-4524 n-4525)
+                          (let ((key-4526
+                                  (car (let ((t-4533 (assq n-4525 r-4431)))
+                                         (if t-4533
+                                           (cdr t-4533)
+                                           (if (symbol? n-4525)
+                                             (let ((t-4538
+                                                     
(get-global-definition-hook-4224
+                                                       n-4525
+                                                       mod-4434)))
+                                               (if t-4538 t-4538 '(global)))
                                              '(displaced-lexical)))))))
-                            (if (eqv? key-4564 'displaced-lexical)
+                            (if (eqv? key-4526 'displaced-lexical)
                               (syntax-violation
                                 'syntax-parameterize
                                 "identifier out of context"
-                                e-4466
-                                (wrap-4324
+                                e-4430
+                                (wrap-4290
                                   (begin
-                                    (if (if s-4469
-                                          (supports-source-properties? id-4562)
+                                    (if (if s-4433
+                                          (supports-source-properties? id-4524)
                                           #f)
-                                      (set-source-properties! id-4562 s-4469))
-                                    id-4562)
-                                  w-4468
-                                  mod-4470)))))
-                        var-4557
-                        names-4561)
-                      (expand-body-4335
-                        (cons e1-4559 e2-4560)
-                        (wrap-4324
+                                      (set-source-properties! id-4524 s-4433))
+                                    id-4524)
+                                  w-4432
+                                  mod-4434)))))
+                        var-4519
+                        names-4523)
+                      (expand-body-4301
+                        (cons e1-4521 e2-4522)
+                        (wrap-4290
                           (begin
-                            (if (if s-4469
-                                  (supports-source-properties? e-4466)
+                            (if (if s-4433
+                                  (supports-source-properties? e-4430)
                                   #f)
-                              (set-source-properties! e-4466 s-4469))
-                            e-4466)
-                          w-4468
-                          mod-4470)
-                        (extend-env-4289
-                          names-4561
-                          (let ((trans-r-4697 (macros-only-env-4291 r-4467)))
-                            (map (lambda (x-4698)
+                              (set-source-properties! e-4430 s-4433))
+                            e-4430)
+                          w-4432
+                          mod-4434)
+                        (extend-env-4255
+                          names-4523
+                          (let ((trans-r-4659 (macros-only-env-4257 r-4431)))
+                            (map (lambda (x-4660)
                                    (cons 'macro
-                                         (eval-local-transformer-4337
-                                           (expand-4331
-                                             x-4698
-                                             trans-r-4697
-                                             w-4468
-                                             mod-4470)
-                                           mod-4470)))
-                                 val-4558))
-                          r-4467)
-                        w-4468
-                        mod-4470))))
-                tmp-4472)
+                                         (eval-local-transformer-4303
+                                           (call-with-values
+                                             (lambda ()
+                                               (syntax-type-4296
+                                                 x-4660
+                                                 trans-r-4659
+                                                 w-4432
+                                                 (let ((props-4717
+                                                         (source-properties
+                                                           (if (if (vector?
+                                                                     x-4660)
+                                                                 (if (= 
(vector-length
+                                                                          
x-4660)
+                                                                        4)
+                                                                   (eq? 
(vector-ref
+                                                                          
x-4660
+                                                                          0)
+                                                                        
'syntax-object)
+                                                                   #f)
+                                                                 #f)
+                                                             (vector-ref
+                                                               x-4660
+                                                               1)
+                                                             x-4660))))
+                                                   (if (pair? props-4717)
+                                                     props-4717
+                                                     #f))
+                                                 #f
+                                                 mod-4434
+                                                 #f))
+                                             (lambda (type-4750
+                                                      value-4751
+                                                      form-4752
+                                                      e-4753
+                                                      w-4754
+                                                      s-4755
+                                                      mod-4756)
+                                               (expand-expr-4298
+                                                 type-4750
+                                                 value-4751
+                                                 form-4752
+                                                 e-4753
+                                                 trans-r-4659
+                                                 w-4754
+                                                 s-4755
+                                                 mod-4756)))
+                                           mod-4434)))
+                                 val-4520))
+                          r-4431)
+                        w-4432
+                        mod-4434))))
+                tmp-4436)
               (syntax-violation
                 'syntax-parameterize
                 "bad syntax"
-                (wrap-4324
+                (wrap-4290
                   (begin
-                    (if (if s-4469
-                          (supports-source-properties? e-4466)
+                    (if (if s-4433
+                          (supports-source-properties? e-4430)
                           #f)
-                      (set-source-properties! e-4466 s-4469))
-                    e-4466)
-                  w-4468
-                  mod-4470))))))
+                      (set-source-properties! e-4430 s-4433))
+                    e-4430)
+                  w-4432
+                  mod-4434))))))
       (module-define!
         (current-module)
         'quote
         (make-syntax-transformer
           'quote
           'core
-          (lambda (e-4907 r-4908 w-4909 s-4910 mod-4911)
-            (let ((tmp-4913 ($sc-dispatch e-4907 '(_ any))))
-              (if tmp-4913
+          (lambda (e-4855 r-4856 w-4857 s-4858 mod-4859)
+            (let ((tmp-4861 ($sc-dispatch e-4855 '(_ any))))
+              (if tmp-4861
                 (@apply
-                  (lambda (e-4916)
-                    (let ((exp-4920 (strip-4344 e-4916 w-4909)))
+                  (lambda (e-4862)
+                    (let ((exp-4866 (strip-4310 e-4862 w-4857)))
                       (make-struct/no-tail
                         (vector-ref %expanded-vtables 1)
-                        s-4910
-                        exp-4920)))
-                  tmp-4913)
+                        s-4858
+                        exp-4866)))
+                  tmp-4861)
                 (syntax-violation
                   'quote
                   "bad syntax"
-                  (wrap-4324
+                  (wrap-4290
                     (begin
-                      (if (if s-4910
-                            (supports-source-properties? e-4907)
+                      (if (if s-4858
+                            (supports-source-properties? e-4855)
                             #f)
-                        (set-source-properties! e-4907 s-4910))
-                      e-4907)
-                    w-4909
-                    mod-4911)))))))
-      (global-extend-4293
+                        (set-source-properties! e-4855 s-4858))
+                      e-4855)
+                    w-4857
+                    mod-4859)))))))
+      (global-extend-4259
         'core
         'syntax
         (letrec*
-          ((gen-syntax-5140
-             (lambda (src-5242
-                      e-5243
-                      r-5244
-                      maps-5245
-                      ellipsis?-5246
-                      mod-5247)
-               (if (if (symbol? e-5243)
+          ((gen-syntax-5078
+             (lambda (src-5175
+                      e-5176
+                      r-5177
+                      maps-5178
+                      ellipsis?-5179
+                      mod-5180)
+               (if (if (symbol? e-5176)
                      #t
-                     (if (if (vector? e-5243)
-                           (if (= (vector-length e-5243) 4)
-                             (eq? (vector-ref e-5243 0) 'syntax-object)
+                     (if (if (vector? e-5176)
+                           (if (= (vector-length e-5176) 4)
+                             (eq? (vector-ref e-5176 0) 'syntax-object)
                              #f)
                            #f)
-                       (symbol? (vector-ref e-5243 1))
+                       (symbol? (vector-ref e-5176 1))
                        #f))
-                 (let ((label-5274 (id-var-name-4314 e-5243 '(()))))
-                   (let ((b-5275
-                           (let ((t-5282 (assq label-5274 r-5244)))
-                             (if t-5282
-                               (cdr t-5282)
-                               (if (symbol? label-5274)
-                                 (let ((t-5288
-                                         (get-global-definition-hook-4258
-                                           label-5274
-                                           mod-5247)))
-                                   (if t-5288 t-5288 '(global)))
+                 (let ((label-5207 (id-var-name-4280 e-5176 '(()))))
+                   (let ((b-5208
+                           (let ((t-5215 (assq label-5207 r-5177)))
+                             (if t-5215
+                               (cdr t-5215)
+                               (if (symbol? label-5207)
+                                 (let ((t-5221
+                                         (get-global-definition-hook-4224
+                                           label-5207
+                                           mod-5180)))
+                                   (if t-5221 t-5221 '(global)))
                                  '(displaced-lexical))))))
-                     (if (eq? (car b-5275) 'syntax)
+                     (if (eq? (car b-5208) 'syntax)
                        (call-with-values
                          (lambda ()
-                           (let ((var.lev-5297 (cdr b-5275)))
-                             (gen-ref-5141
-                               src-5242
-                               (car var.lev-5297)
-                               (cdr var.lev-5297)
-                               maps-5245)))
-                         (lambda (var-5301 maps-5302)
-                           (values (list 'ref var-5301) maps-5302)))
-                       (if (ellipsis?-5246 e-5243)
+                           (let ((var.lev-5230 (cdr b-5208)))
+                             (gen-ref-5079
+                               src-5175
+                               (car var.lev-5230)
+                               (cdr var.lev-5230)
+                               maps-5178)))
+                         (lambda (var-5234 maps-5235)
+                           (values (list 'ref var-5234) maps-5235)))
+                       (if (ellipsis?-5179 e-5176)
                          (syntax-violation
                            'syntax
                            "misplaced ellipsis"
-                           src-5242)
-                         (values (list 'quote e-5243) maps-5245)))))
-                 (let ((tmp-5304 ($sc-dispatch e-5243 '(any any))))
-                   (if (if tmp-5304
+                           src-5175)
+                         (values (list 'quote e-5176) maps-5178)))))
+                 (let ((tmp-5237 ($sc-dispatch e-5176 '(any any))))
+                   (if (if tmp-5237
                          (@apply
-                           (lambda (dots-5308 e-5309)
-                             (ellipsis?-5246 dots-5308))
-                           tmp-5304)
+                           (lambda (dots-5241 e-5242)
+                             (ellipsis?-5179 dots-5241))
+                           tmp-5237)
                          #f)
                      (@apply
-                       (lambda (dots-5310 e-5311)
-                         (gen-syntax-5140
-                           src-5242
-                           e-5311
-                           r-5244
-                           maps-5245
-                           (lambda (x-5312) #f)
-                           mod-5247))
-                       tmp-5304)
-                     (let ((tmp-5313 ($sc-dispatch e-5243 '(any any . any))))
-                       (if (if tmp-5313
+                       (lambda (dots-5243 e-5244)
+                         (gen-syntax-5078
+                           src-5175
+                           e-5244
+                           r-5177
+                           maps-5178
+                           (lambda (x-5245) #f)
+                           mod-5180))
+                       tmp-5237)
+                     (let ((tmp-5246 ($sc-dispatch e-5176 '(any any . any))))
+                       (if (if tmp-5246
                              (@apply
-                               (lambda (x-5317 dots-5318 y-5319)
-                                 (ellipsis?-5246 dots-5318))
-                               tmp-5313)
+                               (lambda (x-5250 dots-5251 y-5252)
+                                 (ellipsis?-5179 dots-5251))
+                               tmp-5246)
                              #f)
                          (@apply
-                           (lambda (x-5320 dots-5321 y-5322)
+                           (lambda (x-5253 dots-5254 y-5255)
                              (letrec*
-                               ((f-5323
-                                  (lambda (y-5331 k-5332)
-                                    (let ((tmp-5334
+                               ((f-5256
+                                  (lambda (y-5264 k-5265)
+                                    (let ((tmp-5267
                                             ($sc-dispatch
-                                              y-5331
+                                              y-5264
                                               '(any . any))))
-                                      (if (if tmp-5334
+                                      (if (if tmp-5267
                                             (@apply
-                                              (lambda (dots-5338 y-5339)
-                                                (ellipsis?-5246 dots-5338))
-                                              tmp-5334)
+                                              (lambda (dots-5269 y-5270)
+                                                (ellipsis?-5179 dots-5269))
+                                              tmp-5267)
                                             #f)
                                         (@apply
-                                          (lambda (dots-5340 y-5341)
-                                            (f-5323
-                                              y-5341
-                                              (lambda (maps-5342)
+                                          (lambda (dots-5271 y-5272)
+                                            (f-5256
+                                              y-5272
+                                              (lambda (maps-5273)
                                                 (call-with-values
                                                   (lambda ()
-                                                    (k-5332
-                                                      (cons '() maps-5342)))
-                                                  (lambda (x-5343 maps-5344)
-                                                    (if (null? (car maps-5344))
+                                                    (k-5265
+                                                      (cons '() maps-5273)))
+                                                  (lambda (x-5274 maps-5275)
+                                                    (if (null? (car maps-5275))
                                                       (syntax-violation
                                                         'syntax
                                                         "extra ellipsis"
-                                                        src-5242)
+                                                        src-5175)
                                                       (values
-                                                        (let ((map-env-5348
-                                                                (car 
maps-5344)))
+                                                        (let ((map-env-5279
+                                                                (car 
maps-5275)))
                                                           (list 'apply
                                                                 '(primitive
                                                                    append)
-                                                                (gen-map-5143
-                                                                  x-5343
-                                                                  
map-env-5348)))
-                                                        (cdr maps-5344))))))))
-                                          tmp-5334)
+                                                                (gen-map-5081
+                                                                  x-5274
+                                                                  
map-env-5279)))
+                                                        (cdr maps-5275))))))))
+                                          tmp-5267)
                                         (call-with-values
                                           (lambda ()
-                                            (gen-syntax-5140
-                                              src-5242
-                                              y-5331
-                                              r-5244
-                                              maps-5245
-                                              ellipsis?-5246
-                                              mod-5247))
-                                          (lambda (y-5351 maps-5352)
+                                            (gen-syntax-5078
+                                              src-5175
+                                              y-5264
+                                              r-5177
+                                              maps-5178
+                                              ellipsis?-5179
+                                              mod-5180))
+                                          (lambda (y-5281 maps-5282)
                                             (call-with-values
-                                              (lambda () (k-5332 maps-5352))
-                                              (lambda (x-5353 maps-5354)
+                                              (lambda () (k-5265 maps-5282))
+                                              (lambda (x-5283 maps-5284)
                                                 (values
-                                                  (if (equal? y-5351 ''())
-                                                    x-5353
+                                                  (if (equal? y-5281 ''())
+                                                    x-5283
                                                     (list 'append
-                                                          x-5353
-                                                          y-5351))
-                                                  maps-5354))))))))))
-                               (f-5323
-                                 y-5322
-                                 (lambda (maps-5326)
+                                                          x-5283
+                                                          y-5281))
+                                                  maps-5284))))))))))
+                               (f-5256
+                                 y-5255
+                                 (lambda (maps-5259)
                                    (call-with-values
                                      (lambda ()
-                                       (gen-syntax-5140
-                                         src-5242
-                                         x-5320
-                                         r-5244
-                                         (cons '() maps-5326)
-                                         ellipsis?-5246
-                                         mod-5247))
-                                     (lambda (x-5327 maps-5328)
-                                       (if (null? (car maps-5328))
+                                       (gen-syntax-5078
+                                         src-5175
+                                         x-5253
+                                         r-5177
+                                         (cons '() maps-5259)
+                                         ellipsis?-5179
+                                         mod-5180))
+                                     (lambda (x-5260 maps-5261)
+                                       (if (null? (car maps-5261))
                                          (syntax-violation
                                            'syntax
                                            "extra ellipsis"
-                                           src-5242)
+                                           src-5175)
                                          (values
-                                           (gen-map-5143
-                                             x-5327
-                                             (car maps-5328))
-                                           (cdr maps-5328)))))))))
-                           tmp-5313)
-                         (let ((tmp-5370 ($sc-dispatch e-5243 '(any . any))))
-                           (if tmp-5370
+                                           (gen-map-5081
+                                             x-5260
+                                             (car maps-5261))
+                                           (cdr maps-5261)))))))))
+                           tmp-5246)
+                         (let ((tmp-5298 ($sc-dispatch e-5176 '(any . any))))
+                           (if tmp-5298
                              (@apply
-                               (lambda (x-5374 y-5375)
+                               (lambda (x-5302 y-5303)
                                  (call-with-values
                                    (lambda ()
-                                     (gen-syntax-5140
-                                       src-5242
-                                       x-5374
-                                       r-5244
-                                       maps-5245
-                                       ellipsis?-5246
-                                       mod-5247))
-                                   (lambda (x-5376 maps-5377)
+                                     (gen-syntax-5078
+                                       src-5175
+                                       x-5302
+                                       r-5177
+                                       maps-5178
+                                       ellipsis?-5179
+                                       mod-5180))
+                                   (lambda (x-5304 maps-5305)
                                      (call-with-values
                                        (lambda ()
-                                         (gen-syntax-5140
-                                           src-5242
-                                           y-5375
-                                           r-5244
-                                           maps-5377
-                                           ellipsis?-5246
-                                           mod-5247))
-                                       (lambda (y-5378 maps-5379)
+                                         (gen-syntax-5078
+                                           src-5175
+                                           y-5303
+                                           r-5177
+                                           maps-5305
+                                           ellipsis?-5179
+                                           mod-5180))
+                                       (lambda (y-5306 maps-5307)
                                          (values
-                                           (let ((key-5384 (car y-5378)))
-                                             (if (eqv? key-5384 'quote)
-                                               (if (eq? (car x-5376) 'quote)
+                                           (let ((key-5312 (car y-5306)))
+                                             (if (eqv? key-5312 'quote)
+                                               (if (eq? (car x-5304) 'quote)
                                                  (list 'quote
-                                                       (cons (car (cdr x-5376))
-                                                             (car (cdr 
y-5378))))
-                                                 (if (eq? (car (cdr y-5378))
+                                                       (cons (car (cdr x-5304))
+                                                             (car (cdr 
y-5306))))
+                                                 (if (eq? (car (cdr y-5306))
                                                           '())
-                                                   (list 'list x-5376)
-                                                   (list 'cons x-5376 y-5378)))
-                                               (if (eqv? key-5384 'list)
+                                                   (list 'list x-5304)
+                                                   (list 'cons x-5304 y-5306)))
+                                               (if (eqv? key-5312 'list)
                                                  (cons 'list
-                                                       (cons x-5376
-                                                             (cdr y-5378)))
-                                                 (list 'cons x-5376 y-5378))))
-                                           maps-5379))))))
-                               tmp-5370)
-                             (let ((tmp-5413
+                                                       (cons x-5304
+                                                             (cdr y-5306)))
+                                                 (list 'cons x-5304 y-5306))))
+                                           maps-5307))))))
+                               tmp-5298)
+                             (let ((tmp-5341
                                      ($sc-dispatch
-                                       e-5243
+                                       e-5176
                                        '#(vector (any . each-any)))))
-                               (if tmp-5413
+                               (if tmp-5341
                                  (@apply
-                                   (lambda (e1-5417 e2-5418)
+                                   (lambda (e1-5345 e2-5346)
                                      (call-with-values
                                        (lambda ()
-                                         (gen-syntax-5140
-                                           src-5242
-                                           (cons e1-5417 e2-5418)
-                                           r-5244
-                                           maps-5245
-                                           ellipsis?-5246
-                                           mod-5247))
-                                       (lambda (e-5419 maps-5420)
+                                         (gen-syntax-5078
+                                           src-5175
+                                           (cons e1-5345 e2-5346)
+                                           r-5177
+                                           maps-5178
+                                           ellipsis?-5179
+                                           mod-5180))
+                                       (lambda (e-5347 maps-5348)
                                          (values
-                                           (if (eq? (car e-5419) 'list)
-                                             (cons 'vector (cdr e-5419))
-                                             (if (eq? (car e-5419) 'quote)
+                                           (if (eq? (car e-5347) 'list)
+                                             (cons 'vector (cdr e-5347))
+                                             (if (eq? (car e-5347) 'quote)
                                                (list 'quote
                                                      (list->vector
-                                                       (car (cdr e-5419))))
-                                               (list 'list->vector e-5419)))
-                                           maps-5420))))
-                                   tmp-5413)
+                                                       (car (cdr e-5347))))
+                                               (list 'list->vector e-5347)))
+                                           maps-5348))))
+                                   tmp-5341)
                                  (values
-                                   (list 'quote e-5243)
-                                   maps-5245))))))))))))
-           (gen-ref-5141
-             (lambda (src-5447 var-5448 level-5449 maps-5450)
-               (if (= level-5449 0)
-                 (values var-5448 maps-5450)
-                 (if (null? maps-5450)
+                                   (list 'quote e-5176)
+                                   maps-5178))))))))))))
+           (gen-ref-5079
+             (lambda (src-5374 var-5375 level-5376 maps-5377)
+               (if (= level-5376 0)
+                 (values var-5375 maps-5377)
+                 (if (null? maps-5377)
                    (syntax-violation
                      'syntax
                      "missing ellipsis"
-                     src-5447)
+                     src-5374)
                    (call-with-values
                      (lambda ()
-                       (gen-ref-5141
-                         src-5447
-                         var-5448
-                         (#{1-}# level-5449)
-                         (cdr maps-5450)))
-                     (lambda (outer-var-5451 outer-maps-5452)
-                       (let ((b-5453 (assq outer-var-5451 (car maps-5450))))
-                         (if b-5453
-                           (values (cdr b-5453) maps-5450)
-                           (let ((inner-var-5455
+                       (gen-ref-5079
+                         src-5374
+                         var-5375
+                         (#{1-}# level-5376)
+                         (cdr maps-5377)))
+                     (lambda (outer-var-5378 outer-maps-5379)
+                       (let ((b-5380 (assq outer-var-5378 (car maps-5377))))
+                         (if b-5380
+                           (values (cdr b-5380) maps-5377)
+                           (let ((inner-var-5382
                                    (gensym
                                      (string-append
                                        (symbol->string 'tmp)
                                        "-"))))
                              (values
-                               inner-var-5455
-                               (cons (cons (cons outer-var-5451 inner-var-5455)
-                                           (car maps-5450))
-                                     outer-maps-5452)))))))))))
-           (gen-map-5143
-             (lambda (e-5469 map-env-5470)
-               (let ((formals-5471 (map cdr map-env-5470))
-                     (actuals-5472
-                       (map (lambda (x-5474) (list 'ref (car x-5474)))
-                            map-env-5470)))
-                 (if (eq? (car e-5469) 'ref)
-                   (car actuals-5472)
+                               inner-var-5382
+                               (cons (cons (cons outer-var-5378 inner-var-5382)
+                                           (car maps-5377))
+                                     outer-maps-5379)))))))))))
+           (gen-map-5081
+             (lambda (e-5396 map-env-5397)
+               (let ((formals-5398 (map cdr map-env-5397))
+                     (actuals-5399
+                       (map (lambda (x-5401) (list 'ref (car x-5401)))
+                            map-env-5397)))
+                 (if (eq? (car e-5396) 'ref)
+                   (car actuals-5399)
                    (if (and-map
-                         (lambda (x-5475)
-                           (if (eq? (car x-5475) 'ref)
-                             (memq (car (cdr x-5475)) formals-5471)
+                         (lambda (x-5402)
+                           (if (eq? (car x-5402) 'ref)
+                             (memq (car (cdr x-5402)) formals-5398)
                              #f))
-                         (cdr e-5469))
+                         (cdr e-5396))
                      (cons 'map
-                           (cons (list 'primitive (car e-5469))
-                                 (map (let ((r-5477
+                           (cons (list 'primitive (car e-5396))
+                                 (map (let ((r-5404
                                               (map cons
-                                                   formals-5471
-                                                   actuals-5472)))
-                                        (lambda (x-5478)
-                                          (cdr (assq (car (cdr x-5478))
-                                                     r-5477))))
-                                      (cdr e-5469))))
+                                                   formals-5398
+                                                   actuals-5399)))
+                                        (lambda (x-5405)
+                                          (cdr (assq (car (cdr x-5405))
+                                                     r-5404))))
+                                      (cdr e-5396))))
                      (cons 'map
-                           (cons (list 'lambda formals-5471 e-5469)
-                                 actuals-5472)))))))
-           (regen-5147
-             (lambda (x-5480)
-               (let ((key-5481 (car x-5480)))
-                 (if (eqv? key-5481 'ref)
-                   (let ((name-5491 (car (cdr x-5480)))
-                         (var-5492 (car (cdr x-5480))))
+                           (cons (list 'lambda formals-5398 e-5396)
+                                 actuals-5399)))))))
+           (regen-5085
+             (lambda (x-5407)
+               (let ((key-5408 (car x-5407)))
+                 (if (eqv? key-5408 'ref)
+                   (let ((name-5418 (car (cdr x-5407)))
+                         (var-5419 (car (cdr x-5407))))
                      (make-struct/no-tail
                        (vector-ref %expanded-vtables 3)
                        #f
-                       name-5491
-                       var-5492))
-                   (if (eqv? key-5481 'primitive)
-                     (let ((name-5504 (car (cdr x-5480))))
+                       name-5418
+                       var-5419))
+                   (if (eqv? key-5408 'primitive)
+                     (let ((name-5431 (car (cdr x-5407))))
                        (if (equal? (module-name (current-module)) '(guile))
                          (make-struct/no-tail
                            (vector-ref %expanded-vtables 7)
                            #f
-                           name-5504)
+                           name-5431)
                          (make-struct/no-tail
                            (vector-ref %expanded-vtables 5)
                            #f
                            '(guile)
-                           name-5504
+                           name-5431
                            #f)))
-                     (if (eqv? key-5481 'quote)
-                       (let ((exp-5522 (car (cdr x-5480))))
+                     (if (eqv? key-5408 'quote)
+                       (let ((exp-5449 (car (cdr x-5407))))
                          (make-struct/no-tail
                            (vector-ref %expanded-vtables 1)
                            #f
-                           exp-5522))
-                       (if (eqv? key-5481 'lambda)
-                         (if (list? (car (cdr x-5480)))
-                           (let ((req-5533 (car (cdr x-5480)))
-                                 (vars-5535 (car (cdr x-5480)))
-                                 (exp-5537
-                                   (regen-5147 (car (cdr (cdr x-5480))))))
-                             (let ((body-5542
+                           exp-5449))
+                       (if (eqv? key-5408 'lambda)
+                         (if (list? (car (cdr x-5407)))
+                           (let ((req-5460 (car (cdr x-5407)))
+                                 (vars-5462 (car (cdr x-5407)))
+                                 (exp-5464
+                                   (regen-5085 (car (cdr (cdr x-5407))))))
+                             (let ((body-5469
                                      (make-struct/no-tail
                                        (vector-ref %expanded-vtables 14)
                                        #f
-                                       req-5533
+                                       req-5460
                                        #f
                                        #f
                                        #f
                                        '()
-                                       vars-5535
-                                       exp-5537
+                                       vars-5462
+                                       exp-5464
                                        #f)))
                                (make-struct/no-tail
                                  (vector-ref %expanded-vtables 13)
                                  #f
                                  '()
-                                 body-5542)))
-                           (error "how did we get here" x-5480))
-                         (let ((fun-exp-5558
-                                 (let ((name-5567 (car x-5480)))
+                                 body-5469)))
+                           (error "how did we get here" x-5407))
+                         (let ((fun-exp-5485
+                                 (let ((name-5494 (car x-5407)))
                                    (if (equal?
                                          (module-name (current-module))
                                          '(guile))
                                      (make-struct/no-tail
                                        (vector-ref %expanded-vtables 7)
                                        #f
-                                       name-5567)
+                                       name-5494)
                                      (make-struct/no-tail
                                        (vector-ref %expanded-vtables 5)
                                        #f
                                        '(guile)
-                                       name-5567
+                                       name-5494
                                        #f))))
-                               (arg-exps-5559 (map regen-5147 (cdr x-5480))))
+                               (arg-exps-5486 (map regen-5085 (cdr x-5407))))
                            (make-struct/no-tail
                              (vector-ref %expanded-vtables 11)
                              #f
-                             fun-exp-5558
-                             arg-exps-5559))))))))))
-          (lambda (e-5148 r-5149 w-5150 s-5151 mod-5152)
-            (let ((e-5153
-                    (wrap-4324
+                             fun-exp-5485
+                             arg-exps-5486))))))))))
+          (lambda (e-5086 r-5087 w-5088 s-5089 mod-5090)
+            (let ((e-5091
+                    (wrap-4290
                       (begin
-                        (if (if s-5151
-                              (supports-source-properties? e-5148)
+                        (if (if s-5089
+                              (supports-source-properties? e-5086)
                               #f)
-                          (set-source-properties! e-5148 s-5151))
-                        e-5148)
-                      w-5150
-                      mod-5152)))
-              (let ((tmp-5155 ($sc-dispatch e-5153 '(_ any))))
-                (if tmp-5155
+                          (set-source-properties! e-5086 s-5089))
+                        e-5086)
+                      w-5088
+                      mod-5090)))
+              (let ((tmp-5093 ($sc-dispatch e-5091 '(_ any))))
+                (if tmp-5093
                   (@apply
-                    (lambda (x-5180)
+                    (lambda (x-5116)
                       (call-with-values
                         (lambda ()
-                          (gen-syntax-5140
-                            e-5153
-                            x-5180
-                            r-5149
+                          (gen-syntax-5078
+                            e-5091
+                            x-5116
+                            r-5087
                             '()
-                            ellipsis?-4339
-                            mod-5152))
-                        (lambda (e-5234 maps-5235) (regen-5147 e-5234))))
-                    tmp-5155)
+                            ellipsis?-4305
+                            mod-5090))
+                        (lambda (e-5170 maps-5171) (regen-5085 e-5170))))
+                    tmp-5093)
                   (syntax-violation
                     'syntax
                     "bad `syntax' form"
-                    e-5153)))))))
-      (global-extend-4293
+                    e-5091)))))))
+      (global-extend-4259
         'core
         'lambda
-        (lambda (e-5755 r-5756 w-5757 s-5758 mod-5759)
-          (let ((tmp-5761
-                  ($sc-dispatch e-5755 '(_ any any . each-any))))
-            (if tmp-5761
+        (lambda (e-5679 r-5680 w-5681 s-5682 mod-5683)
+          (let ((tmp-5685
+                  ($sc-dispatch e-5679 '(_ any any . each-any))))
+            (if tmp-5685
               (@apply
-                (lambda (args-5765 e1-5766 e2-5767)
+                (lambda (args-5687 e1-5688 e2-5689)
                   (call-with-values
-                    (lambda () (lambda-formals-4340 args-5765))
-                    (lambda (req-5770 opt-5771 rest-5772 kw-5773)
+                    (lambda () (lambda-formals-4306 args-5687))
+                    (lambda (req-5692 opt-5693 rest-5694 kw-5695)
                       (letrec*
-                        ((lp-5774
-                           (lambda (body-5777 meta-5778)
-                             (let ((tmp-5780
+                        ((lp-5696
+                           (lambda (body-5699 meta-5700)
+                             (let ((tmp-5702
                                      ($sc-dispatch
-                                       body-5777
+                                       body-5699
                                        '(any any . each-any))))
-                               (if (if tmp-5780
+                               (if (if tmp-5702
                                      (@apply
-                                       (lambda (docstring-5784 e1-5785 e2-5786)
+                                       (lambda (docstring-5706 e1-5707 e2-5708)
                                          (string?
-                                           (syntax->datum docstring-5784)))
-                                       tmp-5780)
+                                           (syntax->datum docstring-5706)))
+                                       tmp-5702)
                                      #f)
                                  (@apply
-                                   (lambda (docstring-5787 e1-5788 e2-5789)
-                                     (lp-5774
-                                       (cons e1-5788 e2-5789)
+                                   (lambda (docstring-5709 e1-5710 e2-5711)
+                                     (lp-5696
+                                       (cons e1-5710 e2-5711)
                                        (append
-                                         meta-5778
+                                         meta-5700
                                          (list (cons 'documentation
                                                      (syntax->datum
-                                                       docstring-5787))))))
-                                   tmp-5780)
-                                 (let ((tmp-5790
+                                                       docstring-5709))))))
+                                   tmp-5702)
+                                 (let ((tmp-5712
                                          ($sc-dispatch
-                                           body-5777
+                                           body-5699
                                            '(#(vector #(each (any . any)))
                                              any
                                              .
                                              each-any))))
-                                   (if tmp-5790
+                                   (if tmp-5712
                                      (@apply
-                                       (lambda (k-5794 v-5795 e1-5796 e2-5797)
-                                         (lp-5774
-                                           (cons e1-5796 e2-5797)
+                                       (lambda (k-5716 v-5717 e1-5718 e2-5719)
+                                         (lp-5696
+                                           (cons e1-5718 e2-5719)
                                            (append
-                                             meta-5778
+                                             meta-5700
                                              (syntax->datum
-                                               (map cons k-5794 v-5795)))))
-                                       tmp-5790)
-                                     (expand-simple-lambda-4341
-                                       e-5755
-                                       r-5756
-                                       w-5757
-                                       s-5758
-                                       mod-5759
-                                       req-5770
-                                       rest-5772
-                                       meta-5778
-                                       body-5777))))))))
-                        (lp-5774 (cons e1-5766 e2-5767) '())))))
-                tmp-5761)
-              (syntax-violation 'lambda "bad lambda" e-5755)))))
-      (global-extend-4293
+                                               (map cons k-5716 v-5717)))))
+                                       tmp-5712)
+                                     (expand-simple-lambda-4307
+                                       e-5679
+                                       r-5680
+                                       w-5681
+                                       s-5682
+                                       mod-5683
+                                       req-5692
+                                       rest-5694
+                                       meta-5700
+                                       body-5699))))))))
+                        (lp-5696 (cons e1-5688 e2-5689) '())))))
+                tmp-5685)
+              (syntax-violation 'lambda "bad lambda" e-5679)))))
+      (global-extend-4259
         'core
         'lambda*
-        (lambda (e-6086 r-6087 w-6088 s-6089 mod-6090)
-          (let ((tmp-6092
-                  ($sc-dispatch e-6086 '(_ any any . each-any))))
-            (if tmp-6092
+        (lambda (e-6002 r-6003 w-6004 s-6005 mod-6006)
+          (let ((tmp-6008
+                  ($sc-dispatch e-6002 '(_ any any . each-any))))
+            (if tmp-6008
               (@apply
-                (lambda (args-6096 e1-6097 e2-6098)
+                (lambda (args-6010 e1-6011 e2-6012)
                   (call-with-values
                     (lambda ()
-                      (expand-lambda-case-4343
-                        e-6086
-                        r-6087
-                        w-6088
-                        s-6089
-                        mod-6090
-                        lambda*-formals-4342
-                        (list (cons args-6096 (cons e1-6097 e2-6098)))))
-                    (lambda (meta-6101 lcase-6102)
+                      (expand-lambda-case-4309
+                        e-6002
+                        r-6003
+                        w-6004
+                        s-6005
+                        mod-6006
+                        lambda*-formals-4308
+                        (list (cons args-6010 (cons e1-6011 e2-6012)))))
+                    (lambda (meta-6015 lcase-6016)
                       (make-struct/no-tail
                         (vector-ref %expanded-vtables 13)
-                        s-6089
-                        meta-6101
-                        lcase-6102))))
-                tmp-6092)
-              (syntax-violation 'lambda "bad lambda*" e-6086)))))
-      (global-extend-4293
+                        s-6005
+                        meta-6015
+                        lcase-6016))))
+                tmp-6008)
+              (syntax-violation 'lambda "bad lambda*" e-6002)))))
+      (global-extend-4259
         'core
         'case-lambda
-        (lambda (e-6272 r-6273 w-6274 s-6275 mod-6276)
-          (let ((tmp-6278
+        (lambda (e-6181 r-6182 w-6183 s-6184 mod-6185)
+          (let ((tmp-6187
                   ($sc-dispatch
-                    e-6272
+                    e-6181
                     '(_ (any any . each-any)
                         .
                         #(each (any any . each-any))))))
-            (if tmp-6278
+            (if tmp-6187
               (@apply
-                (lambda (args-6282
-                         e1-6283
-                         e2-6284
-                         args*-6285
-                         e1*-6286
-                         e2*-6287)
+                (lambda (args-6189
+                         e1-6190
+                         e2-6191
+                         args*-6192
+                         e1*-6193
+                         e2*-6194)
                   (call-with-values
                     (lambda ()
-                      (expand-lambda-case-4343
-                        e-6272
-                        r-6273
-                        w-6274
-                        s-6275
-                        mod-6276
-                        lambda-formals-4340
-                        (cons (cons args-6282 (cons e1-6283 e2-6284))
-                              (map (lambda (tmp-3270-6290
-                                            tmp-3269-6291
-                                            tmp-3268-6292)
-                                     (cons tmp-3268-6292
-                                           (cons tmp-3269-6291 tmp-3270-6290)))
-                                   e2*-6287
-                                   e1*-6286
-                                   args*-6285))))
-                    (lambda (meta-6293 lcase-6294)
+                      (expand-lambda-case-4309
+                        e-6181
+                        r-6182
+                        w-6183
+                        s-6184
+                        mod-6185
+                        lambda-formals-4306
+                        (cons (cons args-6189 (cons e1-6190 e2-6191))
+                              (map (lambda (tmp-3252-6197
+                                            tmp-3251-6198
+                                            tmp-3250-6199)
+                                     (cons tmp-3250-6199
+                                           (cons tmp-3251-6198 tmp-3252-6197)))
+                                   e2*-6194
+                                   e1*-6193
+                                   args*-6192))))
+                    (lambda (meta-6200 lcase-6201)
                       (make-struct/no-tail
                         (vector-ref %expanded-vtables 13)
-                        s-6275
-                        meta-6293
-                        lcase-6294))))
-                tmp-6278)
+                        s-6184
+                        meta-6200
+                        lcase-6201))))
+                tmp-6187)
               (syntax-violation
                 'case-lambda
                 "bad case-lambda"
-                e-6272)))))
-      (global-extend-4293
+                e-6181)))))
+      (global-extend-4259
         'core
         'case-lambda*
-        (lambda (e-6456 r-6457 w-6458 s-6459 mod-6460)
-          (let ((tmp-6462
+        (lambda (e-6358 r-6359 w-6360 s-6361 mod-6362)
+          (let ((tmp-6364
                   ($sc-dispatch
-                    e-6456
+                    e-6358
                     '(_ (any any . each-any)
                         .
                         #(each (any any . each-any))))))
-            (if tmp-6462
+            (if tmp-6364
               (@apply
-                (lambda (args-6466
-                         e1-6467
-                         e2-6468
-                         args*-6469
-                         e1*-6470
-                         e2*-6471)
+                (lambda (args-6366
+                         e1-6367
+                         e2-6368
+                         args*-6369
+                         e1*-6370
+                         e2*-6371)
                   (call-with-values
                     (lambda ()
-                      (expand-lambda-case-4343
-                        e-6456
-                        r-6457
-                        w-6458
-                        s-6459
-                        mod-6460
-                        lambda*-formals-4342
-                        (cons (cons args-6466 (cons e1-6467 e2-6468))
-                              (map (lambda (tmp-3305-6474
-                                            tmp-3304-6475
-                                            tmp-3303-6476)
-                                     (cons tmp-3303-6476
-                                           (cons tmp-3304-6475 tmp-3305-6474)))
-                                   e2*-6471
-                                   e1*-6470
-                                   args*-6469))))
-                    (lambda (meta-6477 lcase-6478)
+                      (expand-lambda-case-4309
+                        e-6358
+                        r-6359
+                        w-6360
+                        s-6361
+                        mod-6362
+                        lambda*-formals-4308
+                        (cons (cons args-6366 (cons e1-6367 e2-6368))
+                              (map (lambda (tmp-3285-6374
+                                            tmp-3284-6375
+                                            tmp-3283-6376)
+                                     (cons tmp-3283-6376
+                                           (cons tmp-3284-6375 tmp-3285-6374)))
+                                   e2*-6371
+                                   e1*-6370
+                                   args*-6369))))
+                    (lambda (meta-6377 lcase-6378)
                       (make-struct/no-tail
                         (vector-ref %expanded-vtables 13)
-                        s-6459
-                        meta-6477
-                        lcase-6478))))
-                tmp-6462)
+                        s-6361
+                        meta-6377
+                        lcase-6378))))
+                tmp-6364)
               (syntax-violation
                 'case-lambda
                 "bad case-lambda*"
-                e-6456)))))
-      (global-extend-4293
+                e-6358)))))
+      (global-extend-4259
         'core
         'let
         (letrec*
-          ((expand-let-6669
-             (lambda (e-6818
-                      r-6819
-                      w-6820
-                      s-6821
-                      mod-6822
-                      constructor-6823
-                      ids-6824
-                      vals-6825
-                      exps-6826)
-               (if (not (valid-bound-ids?-4321 ids-6824))
+          ((expand-let-6566
+             (lambda (e-6714
+                      r-6715
+                      w-6716
+                      s-6717
+                      mod-6718
+                      constructor-6719
+                      ids-6720
+                      vals-6721
+                      exps-6722)
+               (if (not (valid-bound-ids?-4287 ids-6720))
                  (syntax-violation
                    'let
                    "duplicate bound variable"
-                   e-6818)
-                 (let ((labels-6904 (gen-labels-4298 ids-6824))
-                       (new-vars-6905 (map gen-var-4345 ids-6824)))
-                   (let ((nw-6906
-                           (make-binding-wrap-4309
-                             ids-6824
-                             labels-6904
-                             w-6820))
-                         (nr-6907
-                           (extend-var-env-4290
-                             labels-6904
-                             new-vars-6905
-                             r-6819)))
-                     (constructor-6823
-                       s-6821
-                       (map syntax->datum ids-6824)
-                       new-vars-6905
-                       (map (lambda (x-6924)
-                              (expand-4331 x-6924 r-6819 w-6820 mod-6822))
-                            vals-6825)
-                       (expand-body-4335
-                         exps-6826
-                         (source-wrap-4325 e-6818 nw-6906 s-6821 mod-6822)
-                         nr-6907
-                         nw-6906
-                         mod-6822))))))))
-          (lambda (e-6670 r-6671 w-6672 s-6673 mod-6674)
-            (let ((tmp-6676
+                   e-6714)
+                 (let ((labels-6800 (gen-labels-4264 ids-6720))
+                       (new-vars-6801 (map gen-var-4311 ids-6720)))
+                   (let ((nw-6802
+                           (make-binding-wrap-4275
+                             ids-6720
+                             labels-6800
+                             w-6716))
+                         (nr-6803
+                           (extend-var-env-4256
+                             labels-6800
+                             new-vars-6801
+                             r-6715)))
+                     (constructor-6719
+                       s-6717
+                       (map syntax->datum ids-6720)
+                       new-vars-6801
+                       (map (lambda (x-6820)
+                              (call-with-values
+                                (lambda ()
+                                  (syntax-type-4296
+                                    x-6820
+                                    r-6715
+                                    w-6716
+                                    (let ((props-6836
+                                            (source-properties
+                                              (if (if (vector? x-6820)
+                                                    (if (= (vector-length
+                                                             x-6820)
+                                                           4)
+                                                      (eq? (vector-ref
+                                                             x-6820
+                                                             0)
+                                                           'syntax-object)
+                                                      #f)
+                                                    #f)
+                                                (vector-ref x-6820 1)
+                                                x-6820))))
+                                      (if (pair? props-6836) props-6836 #f))
+                                    #f
+                                    mod-6718
+                                    #f))
+                                (lambda (type-6869
+                                         value-6870
+                                         form-6871
+                                         e-6872
+                                         w-6873
+                                         s-6874
+                                         mod-6875)
+                                  (expand-expr-4298
+                                    type-6869
+                                    value-6870
+                                    form-6871
+                                    e-6872
+                                    r-6715
+                                    w-6873
+                                    s-6874
+                                    mod-6875))))
+                            vals-6721)
+                       (expand-body-4301
+                         exps-6722
+                         (source-wrap-4291 e-6714 nw-6802 s-6717 mod-6718)
+                         nr-6803
+                         nw-6802
+                         mod-6718))))))))
+          (lambda (e-6567 r-6568 w-6569 s-6570 mod-6571)
+            (let ((tmp-6573
                     ($sc-dispatch
-                      e-6670
+                      e-6567
                       '(_ #(each (any any)) any . each-any))))
-              (if (if tmp-6676
+              (if (if tmp-6573
                     (@apply
-                      (lambda (id-6680 val-6681 e1-6682 e2-6683)
-                        (and-map id?-4295 id-6680))
-                      tmp-6676)
+                      (lambda (id-6577 val-6578 e1-6579 e2-6580)
+                        (and-map id?-4261 id-6577))
+                      tmp-6573)
                     #f)
                 (@apply
-                  (lambda (id-6699 val-6700 e1-6701 e2-6702)
-                    (expand-let-6669
-                      e-6670
-                      r-6671
-                      w-6672
-                      s-6673
-                      mod-6674
-                      build-let-4277
-                      id-6699
-                      val-6700
-                      (cons e1-6701 e2-6702)))
-                  tmp-6676)
-                (let ((tmp-6732
+                  (lambda (id-6596 val-6597 e1-6598 e2-6599)
+                    (expand-let-6566
+                      e-6567
+                      r-6568
+                      w-6569
+                      s-6570
+                      mod-6571
+                      build-let-4243
+                      id-6596
+                      val-6597
+                      (cons e1-6598 e2-6599)))
+                  tmp-6573)
+                (let ((tmp-6629
                         ($sc-dispatch
-                          e-6670
+                          e-6567
                           '(_ any #(each (any any)) any . each-any))))
-                  (if (if tmp-6732
+                  (if (if tmp-6629
                         (@apply
-                          (lambda (f-6736 id-6737 val-6738 e1-6739 e2-6740)
-                            (if (if (symbol? f-6736)
+                          (lambda (f-6633 id-6634 val-6635 e1-6636 e2-6637)
+                            (if (if (symbol? f-6633)
                                   #t
-                                  (if (if (vector? f-6736)
-                                        (if (= (vector-length f-6736) 4)
-                                          (eq? (vector-ref f-6736 0)
+                                  (if (if (vector? f-6633)
+                                        (if (= (vector-length f-6633) 4)
+                                          (eq? (vector-ref f-6633 0)
                                                'syntax-object)
                                           #f)
                                         #f)
-                                    (symbol? (vector-ref f-6736 1))
+                                    (symbol? (vector-ref f-6633 1))
                                     #f))
-                              (and-map id?-4295 id-6737)
+                              (and-map id?-4261 id-6634)
                               #f))
-                          tmp-6732)
+                          tmp-6629)
                         #f)
                     (@apply
-                      (lambda (f-6782 id-6783 val-6784 e1-6785 e2-6786)
-                        (expand-let-6669
-                          e-6670
-                          r-6671
-                          w-6672
-                          s-6673
-                          mod-6674
-                          build-named-let-4278
-                          (cons f-6782 id-6783)
-                          val-6784
-                          (cons e1-6785 e2-6786)))
-                      tmp-6732)
+                      (lambda (f-6679 id-6680 val-6681 e1-6682 e2-6683)
+                        (expand-let-6566
+                          e-6567
+                          r-6568
+                          w-6569
+                          s-6570
+                          mod-6571
+                          build-named-let-4244
+                          (cons f-6679 id-6680)
+                          val-6681
+                          (cons e1-6682 e2-6683)))
+                      tmp-6629)
                     (syntax-violation
                       'let
                       "bad let"
-                      (wrap-4324
+                      (wrap-4290
                         (begin
-                          (if (if s-6673
-                                (supports-source-properties? e-6670)
+                          (if (if s-6570
+                                (supports-source-properties? e-6567)
                                 #f)
-                            (set-source-properties! e-6670 s-6673))
-                          e-6670)
-                        w-6672
-                        mod-6674)))))))))
-      (global-extend-4293
+                            (set-source-properties! e-6567 s-6570))
+                          e-6567)
+                        w-6569
+                        mod-6571)))))))))
+      (global-extend-4259
         'core
         'letrec
-        (lambda (e-7336 r-7337 w-7338 s-7339 mod-7340)
-          (let ((tmp-7342
+        (lambda (e-7219 r-7220 w-7221 s-7222 mod-7223)
+          (let ((tmp-7225
                   ($sc-dispatch
-                    e-7336
+                    e-7219
                     '(_ #(each (any any)) any . each-any))))
-            (if (if tmp-7342
+            (if (if tmp-7225
                   (@apply
-                    (lambda (id-7346 val-7347 e1-7348 e2-7349)
-                      (and-map id?-4295 id-7346))
-                    tmp-7342)
+                    (lambda (id-7227 val-7228 e1-7229 e2-7230)
+                      (and-map id?-4261 id-7227))
+                    tmp-7225)
                   #f)
               (@apply
-                (lambda (id-7365 val-7366 e1-7367 e2-7368)
-                  (if (not (valid-bound-ids?-4321 id-7365))
+                (lambda (id-7246 val-7247 e1-7248 e2-7249)
+                  (if (not (valid-bound-ids?-4287 id-7246))
                     (syntax-violation
                       'letrec
                       "duplicate bound variable"
-                      e-7336)
-                    (let ((labels-7458 (gen-labels-4298 id-7365))
-                          (new-vars-7459 (map gen-var-4345 id-7365)))
-                      (let ((w-7460
-                              (make-binding-wrap-4309
-                                id-7365
-                                labels-7458
-                                w-7338))
-                            (r-7461
-                              (extend-var-env-4290
-                                labels-7458
-                                new-vars-7459
-                                r-7337)))
-                        (build-letrec-4279
-                          s-7339
+                      e-7219)
+                    (let ((labels-7339 (gen-labels-4264 id-7246))
+                          (new-vars-7340 (map gen-var-4311 id-7246)))
+                      (let ((w-7341
+                              (make-binding-wrap-4275
+                                id-7246
+                                labels-7339
+                                w-7221))
+                            (r-7342
+                              (extend-var-env-4256
+                                labels-7339
+                                new-vars-7340
+                                r-7220)))
+                        (build-letrec-4245
+                          s-7222
                           #f
-                          (map syntax->datum id-7365)
-                          new-vars-7459
-                          (map (lambda (x-7546)
-                                 (expand-4331 x-7546 r-7461 w-7460 mod-7340))
-                               val-7366)
-                          (expand-body-4335
-                            (cons e1-7367 e2-7368)
-                            (wrap-4324
+                          (map syntax->datum id-7246)
+                          new-vars-7340
+                          (map (lambda (x-7427)
+                                 (expand-4297 x-7427 r-7342 w-7341 mod-7223))
+                               val-7247)
+                          (expand-body-4301
+                            (cons e1-7248 e2-7249)
+                            (wrap-4290
                               (begin
-                                (if (if s-7339
-                                      (supports-source-properties? e-7336)
+                                (if (if s-7222
+                                      (supports-source-properties? e-7219)
                                       #f)
-                                  (set-source-properties! e-7336 s-7339))
-                                e-7336)
-                              w-7460
-                              mod-7340)
-                            r-7461
-                            w-7460
-                            mod-7340))))))
-                tmp-7342)
+                                  (set-source-properties! e-7219 s-7222))
+                                e-7219)
+                              w-7341
+                              mod-7223)
+                            r-7342
+                            w-7341
+                            mod-7223))))))
+                tmp-7225)
               (syntax-violation
                 'letrec
                 "bad letrec"
-                (wrap-4324
+                (wrap-4290
                   (begin
-                    (if (if s-7339
-                          (supports-source-properties? e-7336)
+                    (if (if s-7222
+                          (supports-source-properties? e-7219)
                           #f)
-                      (set-source-properties! e-7336 s-7339))
-                    e-7336)
-                  w-7338
-                  mod-7340))))))
-      (global-extend-4293
+                      (set-source-properties! e-7219 s-7222))
+                    e-7219)
+                  w-7221
+                  mod-7223))))))
+      (global-extend-4259
         'core
         'letrec*
-        (lambda (e-7941 r-7942 w-7943 s-7944 mod-7945)
-          (let ((tmp-7947
+        (lambda (e-7817 r-7818 w-7819 s-7820 mod-7821)
+          (let ((tmp-7823
                   ($sc-dispatch
-                    e-7941
+                    e-7817
                     '(_ #(each (any any)) any . each-any))))
-            (if (if tmp-7947
+            (if (if tmp-7823
                   (@apply
-                    (lambda (id-7951 val-7952 e1-7953 e2-7954)
-                      (and-map id?-4295 id-7951))
-                    tmp-7947)
+                    (lambda (id-7825 val-7826 e1-7827 e2-7828)
+                      (and-map id?-4261 id-7825))
+                    tmp-7823)
                   #f)
               (@apply
-                (lambda (id-7970 val-7971 e1-7972 e2-7973)
-                  (if (not (valid-bound-ids?-4321 id-7970))
+                (lambda (id-7844 val-7845 e1-7846 e2-7847)
+                  (if (not (valid-bound-ids?-4287 id-7844))
                     (syntax-violation
                       'letrec*
                       "duplicate bound variable"
-                      e-7941)
-                    (let ((labels-8063 (gen-labels-4298 id-7970))
-                          (new-vars-8064 (map gen-var-4345 id-7970)))
-                      (let ((w-8065
-                              (make-binding-wrap-4309
-                                id-7970
-                                labels-8063
-                                w-7943))
-                            (r-8066
-                              (extend-var-env-4290
-                                labels-8063
-                                new-vars-8064
-                                r-7942)))
-                        (build-letrec-4279
-                          s-7944
+                      e-7817)
+                    (let ((labels-7937 (gen-labels-4264 id-7844))
+                          (new-vars-7938 (map gen-var-4311 id-7844)))
+                      (let ((w-7939
+                              (make-binding-wrap-4275
+                                id-7844
+                                labels-7937
+                                w-7819))
+                            (r-7940
+                              (extend-var-env-4256
+                                labels-7937
+                                new-vars-7938
+                                r-7818)))
+                        (build-letrec-4245
+                          s-7820
                           #t
-                          (map syntax->datum id-7970)
-                          new-vars-8064
-                          (map (lambda (x-8151)
-                                 (expand-4331 x-8151 r-8066 w-8065 mod-7945))
-                               val-7971)
-                          (expand-body-4335
-                            (cons e1-7972 e2-7973)
-                            (wrap-4324
+                          (map syntax->datum id-7844)
+                          new-vars-7938
+                          (map (lambda (x-8025)
+                                 (expand-4297 x-8025 r-7940 w-7939 mod-7821))
+                               val-7845)
+                          (expand-body-4301
+                            (cons e1-7846 e2-7847)
+                            (wrap-4290
                               (begin
-                                (if (if s-7944
-                                      (supports-source-properties? e-7941)
+                                (if (if s-7820
+                                      (supports-source-properties? e-7817)
                                       #f)
-                                  (set-source-properties! e-7941 s-7944))
-                                e-7941)
-                              w-8065
-                              mod-7945)
-                            r-8066
-                            w-8065
-                            mod-7945))))))
-                tmp-7947)
+                                  (set-source-properties! e-7817 s-7820))
+                                e-7817)
+                              w-7939
+                              mod-7821)
+                            r-7940
+                            w-7939
+                            mod-7821))))))
+                tmp-7823)
               (syntax-violation
                 'letrec*
                 "bad letrec*"
-                (wrap-4324
+                (wrap-4290
                   (begin
-                    (if (if s-7944
-                          (supports-source-properties? e-7941)
+                    (if (if s-7820
+                          (supports-source-properties? e-7817)
                           #f)
-                      (set-source-properties! e-7941 s-7944))
-                    e-7941)
-                  w-7943
-                  mod-7945))))))
-      (global-extend-4293
+                      (set-source-properties! e-7817 s-7820))
+                    e-7817)
+                  w-7819
+                  mod-7821))))))
+      (global-extend-4259
         'core
         'set!
-        (lambda (e-8585 r-8586 w-8587 s-8588 mod-8589)
-          (let ((tmp-8591 ($sc-dispatch e-8585 '(_ any any))))
-            (if (if tmp-8591
+        (lambda (e-8488 r-8489 w-8490 s-8491 mod-8492)
+          (let ((tmp-8494 ($sc-dispatch e-8488 '(_ any any))))
+            (if (if tmp-8494
                   (@apply
-                    (lambda (id-8595 val-8596)
-                      (if (symbol? id-8595)
+                    (lambda (id-8498 val-8499)
+                      (if (symbol? id-8498)
                         #t
-                        (if (if (vector? id-8595)
-                              (if (= (vector-length id-8595) 4)
-                                (eq? (vector-ref id-8595 0) 'syntax-object)
+                        (if (if (vector? id-8498)
+                              (if (= (vector-length id-8498) 4)
+                                (eq? (vector-ref id-8498 0) 'syntax-object)
                                 #f)
                               #f)
-                          (symbol? (vector-ref id-8595 1))
+                          (symbol? (vector-ref id-8498 1))
                           #f)))
-                    tmp-8591)
+                    tmp-8494)
                   #f)
               (@apply
-                (lambda (id-8623 val-8624)
-                  (let ((n-8625 (id-var-name-4314 id-8623 w-8587))
-                        (id-mod-8626
-                          (if (if (vector? id-8623)
-                                (if (= (vector-length id-8623) 4)
-                                  (eq? (vector-ref id-8623 0) 'syntax-object)
+                (lambda (id-8526 val-8527)
+                  (let ((n-8528 (id-var-name-4280 id-8526 w-8490))
+                        (id-mod-8529
+                          (if (if (vector? id-8526)
+                                (if (= (vector-length id-8526) 4)
+                                  (eq? (vector-ref id-8526 0) 'syntax-object)
                                   #f)
                                 #f)
-                            (vector-ref id-8623 3)
-                            mod-8589)))
-                    (let ((b-8627
-                            (let ((t-8668 (assq n-8625 r-8586)))
-                              (if t-8668
-                                (cdr t-8668)
-                                (if (symbol? n-8625)
-                                  (let ((t-8673
-                                          (get-global-definition-hook-4258
-                                            n-8625
-                                            id-mod-8626)))
-                                    (if t-8673 t-8673 '(global)))
+                            (vector-ref id-8526 3)
+                            mod-8492)))
+                    (let ((b-8530
+                            (let ((t-8571 (assq n-8528 r-8489)))
+                              (if t-8571
+                                (cdr t-8571)
+                                (if (symbol? n-8528)
+                                  (let ((t-8576
+                                          (get-global-definition-hook-4224
+                                            n-8528
+                                            id-mod-8529)))
+                                    (if t-8576 t-8576 '(global)))
                                   '(displaced-lexical))))))
-                      (let ((key-8628 (car b-8627)))
-                        (if (eqv? key-8628 'lexical)
-                          (build-lexical-assignment-4266
-                            s-8588
-                            (syntax->datum id-8623)
-                            (cdr b-8627)
-                            (expand-4331 val-8624 r-8586 w-8587 mod-8589))
-                          (if (eqv? key-8628 'global)
-                            (build-global-assignment-4269
-                              s-8588
-                              n-8625
-                              (expand-4331 val-8624 r-8586 w-8587 mod-8589)
-                              id-mod-8626)
-                            (if (eqv? key-8628 'macro)
-                              (let ((p-8987 (cdr b-8627)))
+                      (let ((key-8531 (car b-8530)))
+                        (if (eqv? key-8531 'lexical)
+                          (let ((name-8588 (syntax->datum id-8526))
+                                (var-8589 (cdr b-8530))
+                                (exp-8590
+                                  (call-with-values
+                                    (lambda ()
+                                      (syntax-type-4296
+                                        val-8527
+                                        r-8489
+                                        w-8490
+                                        (let ((props-8611
+                                                (source-properties
+                                                  (if (if (vector? val-8527)
+                                                        (if (= (vector-length
+                                                                 val-8527)
+                                                               4)
+                                                          (eq? (vector-ref
+                                                                 val-8527
+                                                                 0)
+                                                               'syntax-object)
+                                                          #f)
+                                                        #f)
+                                                    (vector-ref val-8527 1)
+                                                    val-8527))))
+                                          (if (pair? props-8611)
+                                            props-8611
+                                            #f))
+                                        #f
+                                        mod-8492
+                                        #f))
+                                    (lambda (type-8644
+                                             value-8645
+                                             form-8646
+                                             e-8647
+                                             w-8648
+                                             s-8649
+                                             mod-8650)
+                                      (expand-expr-4298
+                                        type-8644
+                                        value-8645
+                                        form-8646
+                                        e-8647
+                                        r-8489
+                                        w-8648
+                                        s-8649
+                                        mod-8650)))))
+                            (begin
+                              (if (if (struct? exp-8590)
+                                    (eq? (struct-vtable exp-8590)
+                                         (vector-ref %expanded-vtables 13))
+                                    #f)
+                                (let ((meta-8662 (struct-ref exp-8590 1)))
+                                  (if (not (assq 'name meta-8662))
+                                    (let ((v-8669
+                                            (cons (cons 'name name-8588)
+                                                  meta-8662)))
+                                      (struct-set! exp-8590 1 v-8669)))))
+                              (make-struct/no-tail
+                                (vector-ref %expanded-vtables 4)
+                                s-8491
+                                name-8588
+                                var-8589
+                                exp-8590)))
+                          (if (eqv? key-8531 'global)
+                            (let ((exp-8685
+                                    (call-with-values
+                                      (lambda ()
+                                        (syntax-type-4296
+                                          val-8527
+                                          r-8489
+                                          w-8490
+                                          (let ((props-8707
+                                                  (source-properties
+                                                    (if (if (vector? val-8527)
+                                                          (if (= (vector-length
+                                                                   val-8527)
+                                                                 4)
+                                                            (eq? (vector-ref
+                                                                   val-8527
+                                                                   0)
+                                                                 
'syntax-object)
+                                                            #f)
+                                                          #f)
+                                                      (vector-ref val-8527 1)
+                                                      val-8527))))
+                                            (if (pair? props-8707)
+                                              props-8707
+                                              #f))
+                                          #f
+                                          mod-8492
+                                          #f))
+                                      (lambda (type-8740
+                                               value-8741
+                                               form-8742
+                                               e-8743
+                                               w-8744
+                                               s-8745
+                                               mod-8746)
+                                        (expand-expr-4298
+                                          type-8740
+                                          value-8741
+                                          form-8742
+                                          e-8743
+                                          r-8489
+                                          w-8744
+                                          s-8745
+                                          mod-8746)))))
+                              (begin
+                                (if (if (struct? exp-8685)
+                                      (eq? (struct-vtable exp-8685)
+                                           (vector-ref %expanded-vtables 13))
+                                      #f)
+                                  (let ((meta-8758 (struct-ref exp-8685 1)))
+                                    (if (not (assq 'name meta-8758))
+                                      (let ((v-8765
+                                              (cons (cons 'name n-8528)
+                                                    meta-8758)))
+                                        (struct-set! exp-8685 1 v-8765)))))
+                                (analyze-variable-4233
+                                  id-mod-8529
+                                  n-8528
+                                  (lambda (mod-8773 var-8774 public?-8775)
+                                    (make-struct/no-tail
+                                      (vector-ref %expanded-vtables 6)
+                                      s-8491
+                                      mod-8773
+                                      var-8774
+                                      public?-8775
+                                      exp-8685))
+                                  (lambda (var-8784)
+                                    (make-struct/no-tail
+                                      (vector-ref %expanded-vtables 8)
+                                      s-8491
+                                      var-8784
+                                      exp-8685)))))
+                            (if (eqv? key-8531 'macro)
+                              (let ((p-8794 (cdr b-8530)))
                                 (if (procedure-property
-                                      p-8987
+                                      p-8794
                                       'variable-transformer)
-                                  (expand-4331
-                                    (expand-macro-4334
-                                      p-8987
-                                      e-8585
-                                      r-8586
-                                      w-8587
-                                      s-8588
-                                      #f
-                                      mod-8589)
-                                    r-8586
-                                    '(())
-                                    mod-8589)
+                                  (let ((e-8799
+                                          (expand-macro-4300
+                                            p-8794
+                                            e-8488
+                                            r-8489
+                                            w-8490
+                                            s-8491
+                                            #f
+                                            mod-8492)))
+                                    (call-with-values
+                                      (lambda ()
+                                        (syntax-type-4296
+                                          e-8799
+                                          r-8489
+                                          '(())
+                                          (let ((props-8810
+                                                  (source-properties
+                                                    (if (if (vector? e-8799)
+                                                          (if (= (vector-length
+                                                                   e-8799)
+                                                                 4)
+                                                            (eq? (vector-ref
+                                                                   e-8799
+                                                                   0)
+                                                                 
'syntax-object)
+                                                            #f)
+                                                          #f)
+                                                      (vector-ref e-8799 1)
+                                                      e-8799))))
+                                            (if (pair? props-8810)
+                                              props-8810
+                                              #f))
+                                          #f
+                                          mod-8492
+                                          #f))
+                                      (lambda (type-8833
+                                               value-8834
+                                               form-8835
+                                               e-8836
+                                               w-8837
+                                               s-8838
+                                               mod-8839)
+                                        (expand-expr-4298
+                                          type-8833
+                                          value-8834
+                                          form-8835
+                                          e-8836
+                                          r-8489
+                                          w-8837
+                                          s-8838
+                                          mod-8839))))
                                   (syntax-violation
                                     'set!
                                     "not a variable transformer"
-                                    (wrap-4324 e-8585 w-8587 mod-8589)
-                                    (wrap-4324 id-8623 w-8587 id-mod-8626))))
-                              (if (eqv? key-8628 'displaced-lexical)
+                                    (wrap-4290 e-8488 w-8490 mod-8492)
+                                    (wrap-4290 id-8526 w-8490 id-mod-8529))))
+                              (if (eqv? key-8531 'displaced-lexical)
                                 (syntax-violation
                                   'set!
                                   "identifier out of context"
-                                  (wrap-4324 id-8623 w-8587 mod-8589))
+                                  (wrap-4290 id-8526 w-8490 mod-8492))
                                 (syntax-violation
                                   'set!
                                   "bad set!"
-                                  (wrap-4324
+                                  (wrap-4290
                                     (begin
-                                      (if (if s-8588
+                                      (if (if s-8491
                                             (supports-source-properties?
-                                              e-8585)
+                                              e-8488)
                                             #f)
-                                        (set-source-properties! e-8585 s-8588))
-                                      e-8585)
-                                    w-8587
-                                    mod-8589))))))))))
-                tmp-8591)
-              (let ((tmp-9082
-                      ($sc-dispatch e-8585 '(_ (any . each-any) any))))
-                (if tmp-9082
+                                        (set-source-properties! e-8488 s-8491))
+                                      e-8488)
+                                    w-8490
+                                    mod-8492))))))))))
+                tmp-8494)
+              (let ((tmp-8874
+                      ($sc-dispatch e-8488 '(_ (any . each-any) any))))
+                (if tmp-8874
                   (@apply
-                    (lambda (head-9086 tail-9087 val-9088)
+                    (lambda (head-8878 tail-8879 val-8880)
                       (call-with-values
                         (lambda ()
-                          (syntax-type-4330
-                            head-9086
-                            r-8586
+                          (syntax-type-4296
+                            head-8878
+                            r-8489
                             '(())
                             #f
                             #f
-                            mod-8589
+                            mod-8492
                             #t))
-                        (lambda (type-9091
-                                 value-9092
-                                 formform-9093
-                                 ee-9094
-                                 ww-9095
-                                 ss-9096
-                                 modmod-9097)
-                          (if (eqv? type-9091 'module-ref)
-                            (let ((val-9103
-                                    (expand-4331
-                                      val-9088
-                                      r-8586
-                                      w-8587
-                                      mod-8589)))
+                        (lambda (type-8883
+                                 value-8884
+                                 formform-8885
+                                 ee-8886
+                                 ww-8887
+                                 ss-8888
+                                 modmod-8889)
+                          (if (eqv? type-8883 'module-ref)
+                            (let ((val-8895
+                                    (call-with-values
+                                      (lambda ()
+                                        (syntax-type-4296
+                                          val-8880
+                                          r-8489
+                                          w-8490
+                                          (let ((props-8962
+                                                  (source-properties
+                                                    (if (if (vector? val-8880)
+                                                          (if (= (vector-length
+                                                                   val-8880)
+                                                                 4)
+                                                            (eq? (vector-ref
+                                                                   val-8880
+                                                                   0)
+                                                                 
'syntax-object)
+                                                            #f)
+                                                          #f)
+                                                      (vector-ref val-8880 1)
+                                                      val-8880))))
+                                            (if (pair? props-8962)
+                                              props-8962
+                                              #f))
+                                          #f
+                                          mod-8492
+                                          #f))
+                                      (lambda (type-8995
+                                               value-8996
+                                               form-8997
+                                               e-8998
+                                               w-8999
+                                               s-9000
+                                               mod-9001)
+                                        (expand-expr-4298
+                                          type-8995
+                                          value-8996
+                                          form-8997
+                                          e-8998
+                                          r-8489
+                                          w-8999
+                                          s-9000
+                                          mod-9001)))))
                               (call-with-values
                                 (lambda ()
-                                  (value-9092
-                                    (cons head-9086 tail-9087)
-                                    r-8586
-                                    w-8587))
-                                (lambda (e-9104 r-9105 w-9106 s*-9107 mod-9108)
-                                  (let ((tmp-9110 (list e-9104)))
+                                  (value-8884
+                                    (cons head-8878 tail-8879)
+                                    r-8489
+                                    w-8490))
+                                (lambda (e-8896 r-8897 w-8898 s*-8899 mod-8900)
+                                  (let ((tmp-8902 (list e-8896)))
                                     (if (@apply
-                                          (lambda (e-9112)
-                                            (if (symbol? e-9112)
+                                          (lambda (e-8904)
+                                            (if (symbol? e-8904)
                                               #t
-                                              (if (if (vector? e-9112)
+                                              (if (if (vector? e-8904)
                                                     (if (= (vector-length
-                                                             e-9112)
+                                                             e-8904)
                                                            4)
                                                       (eq? (vector-ref
-                                                             e-9112
+                                                             e-8904
                                                              0)
                                                            'syntax-object)
                                                       #f)
                                                     #f)
-                                                (symbol? (vector-ref e-9112 1))
+                                                (symbol? (vector-ref e-8904 1))
                                                 #f)))
-                                          tmp-9110)
+                                          tmp-8902)
                                       (@apply
-                                        (lambda (e-9142)
-                                          (build-global-assignment-4269
-                                            s-8588
-                                            (syntax->datum e-9142)
-                                            val-9103
-                                            mod-9108))
-                                        tmp-9110)
+                                        (lambda (e-8934)
+                                          (let ((var-8939
+                                                  (syntax->datum e-8934)))
+                                            (begin
+                                              (if (if (struct? val-8895)
+                                                    (eq? (struct-vtable
+                                                           val-8895)
+                                                         (vector-ref
+                                                           %expanded-vtables
+                                                           13))
+                                                    #f)
+                                                (let ((meta-9017
+                                                        (struct-ref
+                                                          val-8895
+                                                          1)))
+                                                  (if (not (assq 'name
+                                                                 meta-9017))
+                                                    (let ((v-9026
+                                                            (cons (cons 'name
+                                                                        
var-8939)
+                                                                  meta-9017)))
+                                                      (struct-set!
+                                                        val-8895
+                                                        1
+                                                        v-9026)))))
+                                              (analyze-variable-4233
+                                                mod-8900
+                                                var-8939
+                                                (lambda (mod-9032
+                                                         var-9033
+                                                         public?-9034)
+                                                  (make-struct/no-tail
+                                                    (vector-ref
+                                                      %expanded-vtables
+                                                      6)
+                                                    s-8491
+                                                    mod-9032
+                                                    var-9033
+                                                    public?-9034
+                                                    val-8895))
+                                                (lambda (var-9045)
+                                                  (make-struct/no-tail
+                                                    (vector-ref
+                                                      %expanded-vtables
+                                                      8)
+                                                    s-8491
+                                                    var-9045
+                                                    val-8895))))))
+                                        tmp-8902)
                                       (syntax-violation
                                         #f
                                         "source expression failed to match any 
pattern"
-                                        e-9104))))))
-                            (build-application-4262
-                              s-8588
-                              (let ((e-9367
-                                      (list '#(syntax-object
-                                               setter
-                                               ((top)
-                                                #(ribcage () () ())
-                                                #(ribcage
-                                                  #(key)
-                                                  #((m-*-3554 top))
-                                                  #("l-*-3555"))
-                                                #(ribcage () () ())
-                                                #(ribcage () () ())
-                                                #(ribcage
-                                                  #(type
-                                                    value
-                                                    formform
-                                                    ee
-                                                    ww
-                                                    ss
-                                                    modmod)
-                                                  #((top)
-                                                    (top)
-                                                    (top)
-                                                    (top)
-                                                    (top)
-                                                    (top)
-                                                    (top))
-                                                  #("l-*-3547"
-                                                    "l-*-3548"
-                                                    "l-*-3549"
-                                                    "l-*-3550"
-                                                    "l-*-3551"
-                                                    "l-*-3552"
-                                                    "l-*-3553"))
-                                                #(ribcage
-                                                  #(head tail val)
-                                                  #((top) (top) (top))
-                                                  #("l-*-3532"
-                                                    "l-*-3533"
-                                                    "l-*-3534"))
-                                                #(ribcage () () ())
-                                                #(ribcage
-                                                  #(e r w s mod)
-                                                  #((top)
-                                                    (top)
-                                                    (top)
-                                                    (top)
-                                                    (top))
-                                                  #("l-*-3501"
-                                                    "l-*-3502"
-                                                    "l-*-3503"
-                                                    "l-*-3504"
-                                                    "l-*-3505"))
-                                                #(ribcage
-                                                  (lambda-var-list
-                                                    gen-var
-                                                    strip
-                                                    expand-lambda-case
-                                                    lambda*-formals
-                                                    expand-simple-lambda
-                                                    lambda-formals
-                                                    ellipsis?
-                                                    expand-void
-                                                    eval-local-transformer
-                                                    expand-local-syntax
-                                                    expand-body
-                                                    expand-macro
-                                                    expand-application
-                                                    expand-expr
-                                                    expand
-                                                    syntax-type
-                                                    parse-when-list
-                                                    expand-install-global
-                                                    expand-top-sequence
-                                                    expand-sequence
-                                                    source-wrap
-                                                    wrap
-                                                    bound-id-member?
-                                                    distinct-bound-ids?
-                                                    valid-bound-ids?
-                                                    bound-id=?
-                                                    free-id=?
-                                                    
with-transformer-environment
-                                                    transformer-environment
-                                                    resolve-identifier
-                                                    locally-bound-identifiers
-                                                    id-var-name
-                                                    same-marks?
-                                                    join-marks
-                                                    join-wraps
-                                                    smart-append
-                                                    make-binding-wrap
-                                                    extend-ribcage!
-                                                    make-empty-ribcage
-                                                    new-mark
-                                                    anti-mark
-                                                    the-anti-mark
-                                                    top-marked?
-                                                    top-wrap
-                                                    empty-wrap
-                                                    set-ribcage-labels!
-                                                    set-ribcage-marks!
-                                                    set-ribcage-symnames!
-                                                    ribcage-labels
-                                                    ribcage-marks
-                                                    ribcage-symnames
-                                                    ribcage?
-                                                    make-ribcage
-                                                    gen-labels
-                                                    gen-label
-                                                    make-rename
-                                                    rename-marks
-                                                    rename-new
-                                                    rename-old
-                                                    subst-rename?
-                                                    wrap-subst
-                                                    wrap-marks
-                                                    make-wrap
-                                                    id-sym-name&marks
-                                                    id-sym-name
-                                                    id?
-                                                    nonsymbol-id?
-                                                    global-extend
-                                                    lookup
-                                                    macros-only-env
-                                                    extend-var-env
-                                                    extend-env
-                                                    null-env
-                                                    binding-value
-                                                    binding-type
-                                                    make-binding
-                                                    arg-check
-                                                    source-annotation
-                                                    no-source
-                                                    set-syntax-object-module!
-                                                    set-syntax-object-wrap!
-                                                    
set-syntax-object-expression!
-                                                    syntax-object-module
-                                                    syntax-object-wrap
-                                                    syntax-object-expression
-                                                    syntax-object?
-                                                    make-syntax-object
-                                                    build-lexical-var
-                                                    build-letrec
-                                                    build-named-let
-                                                    build-let
-                                                    build-sequence
-                                                    build-data
-                                                    build-primref
-                                                    build-lambda-case
-                                                    build-case-lambda
-                                                    build-simple-lambda
-                                                    build-global-definition
-                                                    build-global-assignment
-                                                    build-global-reference
-                                                    analyze-variable
-                                                    build-lexical-assignment
-                                                    build-lexical-reference
-                                                    build-dynlet
-                                                    build-conditional
-                                                    build-application
-                                                    build-void
-                                                    maybe-name-value!
-                                                    decorate-source
-                                                    get-global-definition-hook
-                                                    put-global-definition-hook
-                                                    session-id
-                                                    local-eval-hook
-                                                    top-level-eval-hook
-                                                    fx<
-                                                    fx=
-                                                    fx-
-                                                    fx+
-                                                    set-lambda-meta!
-                                                    lambda-meta
-                                                    lambda?
-                                                    make-dynlet
-                                                    make-letrec
-                                                    make-let
-                                                    make-lambda-case
-                                                    make-lambda
-                                                    make-sequence
-                                                    make-application
-                                                    make-conditional
-                                                    make-toplevel-define
-                                                    make-toplevel-set
-                                                    make-toplevel-ref
-                                                    make-module-set
-                                                    make-module-ref
-                                                    make-lexical-set
-                                                    make-lexical-ref
-                                                    make-primitive-ref
-                                                    make-const
-                                                    make-void)
-                                                  ((top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top)
-                                                   (top))
-                                                  ("l-*-476"
-                                                   "l-*-474"
-                                                   "l-*-472"
-                                                   "l-*-470"
-                                                   "l-*-468"
-                                                   "l-*-466"
-                                                   "l-*-464"
-                                                   "l-*-462"
-                                                   "l-*-460"
-                                                   "l-*-458"
-                                                   "l-*-456"
-                                                   "l-*-454"
-                                                   "l-*-452"
-                                                   "l-*-450"
-                                                   "l-*-448"
-                                                   "l-*-446"
-                                                   "l-*-444"
-                                                   "l-*-442"
-                                                   "l-*-440"
-                                                   "l-*-438"
-                                                   "l-*-436"
-                                                   "l-*-434"
-                                                   "l-*-432"
-                                                   "l-*-430"
-                                                   "l-*-428"
-                                                   "l-*-426"
-                                                   "l-*-424"
-                                                   "l-*-422"
-                                                   "l-*-420"
-                                                   "l-*-418"
-                                                   "l-*-416"
-                                                   "l-*-414"
-                                                   "l-*-412"
-                                                   "l-*-410"
-                                                   "l-*-408"
-                                                   "l-*-406"
-                                                   "l-*-404"
-                                                   "l-*-402"
-                                                   "l-*-400"
-                                                   "l-*-399"
-                                                   "l-*-397"
-                                                   "l-*-394"
-                                                   "l-*-393"
-                                                   "l-*-392"
-                                                   "l-*-390"
-                                                   "l-*-389"
-                                                   "l-*-387"
-                                                   "l-*-385"
-                                                   "l-*-383"
-                                                   "l-*-381"
-                                                   "l-*-379"
-                                                   "l-*-377"
-                                                   "l-*-375"
-                                                   "l-*-373"
-                                                   "l-*-370"
-                                                   "l-*-368"
-                                                   "l-*-367"
-                                                   "l-*-365"
-                                                   "l-*-363"
-                                                   "l-*-361"
-                                                   "l-*-359"
-                                                   "l-*-358"
-                                                   "l-*-357"
-                                                   "l-*-356"
-                                                   "l-*-354"
-                                                   "l-*-353"
-                                                   "l-*-350"
-                                                   "l-*-348"
-                                                   "l-*-346"
-                                                   "l-*-344"
-                                                   "l-*-342"
-                                                   "l-*-340"
-                                                   "l-*-338"
-                                                   "l-*-337"
-                                                   "l-*-336"
-                                                   "l-*-334"
-                                                   "l-*-332"
-                                                   "l-*-331"
-                                                   "l-*-328"
-                                                   "l-*-327"
-                                                   "l-*-325"
-                                                   "l-*-323"
-                                                   "l-*-321"
-                                                   "l-*-319"
-                                                   "l-*-317"
-                                                   "l-*-315"
-                                                   "l-*-313"
-                                                   "l-*-311"
-                                                   "l-*-309"
-                                                   "l-*-306"
-                                                   "l-*-304"
-                                                   "l-*-302"
-                                                   "l-*-300"
-                                                   "l-*-298"
-                                                   "l-*-296"
-                                                   "l-*-294"
-                                                   "l-*-292"
-                                                   "l-*-290"
-                                                   "l-*-288"
-                                                   "l-*-286"
-                                                   "l-*-284"
-                                                   "l-*-282"
-                                                   "l-*-280"
-                                                   "l-*-278"
-                                                   "l-*-276"
-                                                   "l-*-274"
-                                                   "l-*-272"
-                                                   "l-*-270"
-                                                   "l-*-268"
-                                                   "l-*-266"
-                                                   "l-*-264"
-                                                   "l-*-262"
-                                                   "l-*-260"
-                                                   "l-*-258"
-                                                   "l-*-256"
-                                                   "l-*-255"
-                                                   "l-*-254"
-                                                   "l-*-253"
-                                                   "l-*-252"
-                                                   "l-*-250"
-                                                   "l-*-248"
-                                                   "l-*-246"
-                                                   "l-*-243"
-                                                   "l-*-241"
-                                                   "l-*-239"
-                                                   "l-*-237"
-                                                   "l-*-235"
-                                                   "l-*-233"
-                                                   "l-*-231"
-                                                   "l-*-229"
-                                                   "l-*-227"
-                                                   "l-*-225"
-                                                   "l-*-223"
-                                                   "l-*-221"
-                                                   "l-*-219"
-                                                   "l-*-217"
-                                                   "l-*-215"
-                                                   "l-*-213"
-                                                   "l-*-211"
-                                                   "l-*-209"))
-                                                #(ribcage
-                                                  (define-structure
-                                                    define-expansion-accessors
-                                                    
define-expansion-constructors)
-                                                  ((top) (top) (top))
-                                                  ("l-*-47"
-                                                   "l-*-46"
-                                                   "l-*-45")))
-                                               (hygiene guile))
-                                            head-9086)))
-                                (call-with-values
-                                  (lambda ()
-                                    (syntax-type-4330
-                                      e-9367
-                                      r-8586
-                                      w-8587
-                                      (source-annotation-4288 e-9367)
-                                      #f
-                                      mod-8589
-                                      #f))
-                                  (lambda (type-9374
-                                           value-9375
-                                           form-9376
-                                           e-9377
-                                           w-9378
-                                           s-9379
-                                           mod-9380)
-                                    (expand-expr-4332
-                                      type-9374
-                                      value-9375
-                                      form-9376
-                                      e-9377
-                                      r-8586
-                                      w-9378
-                                      s-9379
-                                      mod-9380))))
-                              (map (lambda (e-9384)
-                                     (call-with-values
-                                       (lambda ()
-                                         (syntax-type-4330
-                                           e-9384
-                                           r-8586
-                                           w-8587
-                                           (source-annotation-4288 e-9384)
-                                           #f
-                                           mod-8589
-                                           #f))
-                                       (lambda (type-9399
-                                                value-9400
-                                                form-9401
-                                                e-9402
-                                                w-9403
-                                                s-9404
-                                                mod-9405)
-                                         (expand-expr-4332
-                                           type-9399
-                                           value-9400
-                                           form-9401
-                                           e-9402
-                                           r-8586
-                                           w-9403
-                                           s-9404
-                                           mod-9405))))
-                                   (append tail-9087 (list val-9088))))))))
-                    tmp-9082)
-                  (syntax-violation
-                    'set!
-                    "bad set!"
-                    (wrap-4324
-                      (begin
-                        (if (if s-8588
-                              (supports-source-properties? e-8585)
-                              #f)
-                          (set-source-properties! e-8585 s-8588))
-                        e-8585)
-                      w-8587
-                      mod-8589))))))))
-      (module-define!
-        (current-module)
-        '@
-        (make-syntax-transformer
-          '@
-          'module-ref
-          (lambda (e-9448 r-9449 w-9450)
-            (let ((tmp-9452
-                    ($sc-dispatch e-9448 '(_ each-any any))))
-              (if (if tmp-9452
-                    (@apply
-                      (lambda (mod-9455 id-9456)
-                        (if (and-map id?-4295 mod-9455)
-                          (if (symbol? id-9456)
-                            #t
-                            (if (if (vector? id-9456)
-                                  (if (= (vector-length id-9456) 4)
-                                    (eq? (vector-ref id-9456 0) 'syntax-object)
-                                    #f)
-                                  #f)
-                              (symbol? (vector-ref id-9456 1))
-                              #f))
-                          #f))
-                      tmp-9452)
-                    #f)
-                (@apply
-                  (lambda (mod-9496 id-9497)
-                    (values
-                      (syntax->datum id-9497)
-                      r-9449
-                      w-9450
-                      #f
-                      (syntax->datum
-                        (cons '#(syntax-object
-                                 public
-                                 ((top)
-                                  #(ribcage
-                                    #(mod id)
-                                    #((top) (top))
-                                    #("l-*-3596" "l-*-3597"))
-                                  #(ribcage () () ())
-                                  #(ribcage
-                                    #(e r w)
-                                    #((top) (top) (top))
-                                    #("l-*-3584" "l-*-3585" "l-*-3586"))
-                                  #(ribcage
-                                    (lambda-var-list
-                                      gen-var
-                                      strip
-                                      expand-lambda-case
-                                      lambda*-formals
-                                      expand-simple-lambda
-                                      lambda-formals
-                                      ellipsis?
-                                      expand-void
-                                      eval-local-transformer
-                                      expand-local-syntax
-                                      expand-body
-                                      expand-macro
-                                      expand-application
-                                      expand-expr
-                                      expand
-                                      syntax-type
-                                      parse-when-list
-                                      expand-install-global
-                                      expand-top-sequence
-                                      expand-sequence
-                                      source-wrap
-                                      wrap
-                                      bound-id-member?
-                                      distinct-bound-ids?
-                                      valid-bound-ids?
-                                      bound-id=?
-                                      free-id=?
-                                      with-transformer-environment
-                                      transformer-environment
-                                      resolve-identifier
-                                      locally-bound-identifiers
-                                      id-var-name
-                                      same-marks?
-                                      join-marks
-                                      join-wraps
-                                      smart-append
-                                      make-binding-wrap
-                                      extend-ribcage!
-                                      make-empty-ribcage
-                                      new-mark
-                                      anti-mark
-                                      the-anti-mark
-                                      top-marked?
-                                      top-wrap
-                                      empty-wrap
-                                      set-ribcage-labels!
-                                      set-ribcage-marks!
-                                      set-ribcage-symnames!
-                                      ribcage-labels
-                                      ribcage-marks
-                                      ribcage-symnames
-                                      ribcage?
-                                      make-ribcage
-                                      gen-labels
-                                      gen-label
-                                      make-rename
-                                      rename-marks
-                                      rename-new
-                                      rename-old
-                                      subst-rename?
-                                      wrap-subst
-                                      wrap-marks
-                                      make-wrap
-                                      id-sym-name&marks
-                                      id-sym-name
-                                      id?
-                                      nonsymbol-id?
-                                      global-extend
-                                      lookup
-                                      macros-only-env
-                                      extend-var-env
-                                      extend-env
-                                      null-env
-                                      binding-value
-                                      binding-type
-                                      make-binding
-                                      arg-check
-                                      source-annotation
-                                      no-source
-                                      set-syntax-object-module!
-                                      set-syntax-object-wrap!
-                                      set-syntax-object-expression!
-                                      syntax-object-module
-                                      syntax-object-wrap
-                                      syntax-object-expression
-                                      syntax-object?
-                                      make-syntax-object
-                                      build-lexical-var
-                                      build-letrec
-                                      build-named-let
-                                      build-let
-                                      build-sequence
-                                      build-data
-                                      build-primref
-                                      build-lambda-case
-                                      build-case-lambda
-                                      build-simple-lambda
-                                      build-global-definition
-                                      build-global-assignment
-                                      build-global-reference
-                                      analyze-variable
-                                      build-lexical-assignment
-                                      build-lexical-reference
-                                      build-dynlet
-                                      build-conditional
-                                      build-application
-                                      build-void
-                                      maybe-name-value!
-                                      decorate-source
-                                      get-global-definition-hook
-                                      put-global-definition-hook
-                                      session-id
-                                      local-eval-hook
-                                      top-level-eval-hook
-                                      fx<
-                                      fx=
-                                      fx-
-                                      fx+
-                                      set-lambda-meta!
-                                      lambda-meta
-                                      lambda?
-                                      make-dynlet
-                                      make-letrec
-                                      make-let
-                                      make-lambda-case
-                                      make-lambda
-                                      make-sequence
-                                      make-application
-                                      make-conditional
-                                      make-toplevel-define
-                                      make-toplevel-set
-                                      make-toplevel-ref
-                                      make-module-set
-                                      make-module-ref
-                                      make-lexical-set
-                                      make-lexical-ref
-                                      make-primitive-ref
-                                      make-const
-                                      make-void)
-                                    ((top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top))
-                                    ("l-*-476"
-                                     "l-*-474"
-                                     "l-*-472"
-                                     "l-*-470"
-                                     "l-*-468"
-                                     "l-*-466"
-                                     "l-*-464"
-                                     "l-*-462"
-                                     "l-*-460"
-                                     "l-*-458"
-                                     "l-*-456"
-                                     "l-*-454"
-                                     "l-*-452"
-                                     "l-*-450"
-                                     "l-*-448"
-                                     "l-*-446"
-                                     "l-*-444"
-                                     "l-*-442"
-                                     "l-*-440"
-                                     "l-*-438"
-                                     "l-*-436"
-                                     "l-*-434"
-                                     "l-*-432"
-                                     "l-*-430"
-                                     "l-*-428"
-                                     "l-*-426"
-                                     "l-*-424"
-                                     "l-*-422"
-                                     "l-*-420"
-                                     "l-*-418"
-                                     "l-*-416"
-                                     "l-*-414"
-                                     "l-*-412"
-                                     "l-*-410"
-                                     "l-*-408"
-                                     "l-*-406"
-                                     "l-*-404"
-                                     "l-*-402"
-                                     "l-*-400"
-                                     "l-*-399"
-                                     "l-*-397"
-                                     "l-*-394"
-                                     "l-*-393"
-                                     "l-*-392"
-                                     "l-*-390"
-                                     "l-*-389"
-                                     "l-*-387"
-                                     "l-*-385"
-                                     "l-*-383"
-                                     "l-*-381"
-                                     "l-*-379"
-                                     "l-*-377"
-                                     "l-*-375"
-                                     "l-*-373"
-                                     "l-*-370"
-                                     "l-*-368"
-                                     "l-*-367"
-                                     "l-*-365"
-                                     "l-*-363"
-                                     "l-*-361"
-                                     "l-*-359"
-                                     "l-*-358"
-                                     "l-*-357"
-                                     "l-*-356"
-                                     "l-*-354"
-                                     "l-*-353"
-                                     "l-*-350"
-                                     "l-*-348"
-                                     "l-*-346"
-                                     "l-*-344"
-                                     "l-*-342"
-                                     "l-*-340"
-                                     "l-*-338"
-                                     "l-*-337"
-                                     "l-*-336"
-                                     "l-*-334"
-                                     "l-*-332"
-                                     "l-*-331"
-                                     "l-*-328"
-                                     "l-*-327"
-                                     "l-*-325"
-                                     "l-*-323"
-                                     "l-*-321"
-                                     "l-*-319"
-                                     "l-*-317"
-                                     "l-*-315"
-                                     "l-*-313"
-                                     "l-*-311"
-                                     "l-*-309"
-                                     "l-*-306"
-                                     "l-*-304"
-                                     "l-*-302"
-                                     "l-*-300"
-                                     "l-*-298"
-                                     "l-*-296"
-                                     "l-*-294"
-                                     "l-*-292"
-                                     "l-*-290"
-                                     "l-*-288"
-                                     "l-*-286"
-                                     "l-*-284"
-                                     "l-*-282"
-                                     "l-*-280"
-                                     "l-*-278"
-                                     "l-*-276"
-                                     "l-*-274"
-                                     "l-*-272"
-                                     "l-*-270"
-                                     "l-*-268"
-                                     "l-*-266"
-                                     "l-*-264"
-                                     "l-*-262"
-                                     "l-*-260"
-                                     "l-*-258"
-                                     "l-*-256"
-                                     "l-*-255"
-                                     "l-*-254"
-                                     "l-*-253"
-                                     "l-*-252"
-                                     "l-*-250"
-                                     "l-*-248"
-                                     "l-*-246"
-                                     "l-*-243"
-                                     "l-*-241"
-                                     "l-*-239"
-                                     "l-*-237"
-                                     "l-*-235"
-                                     "l-*-233"
-                                     "l-*-231"
-                                     "l-*-229"
-                                     "l-*-227"
-                                     "l-*-225"
-                                     "l-*-223"
-                                     "l-*-221"
-                                     "l-*-219"
-                                     "l-*-217"
-                                     "l-*-215"
-                                     "l-*-213"
-                                     "l-*-211"
-                                     "l-*-209"))
-                                  #(ribcage
-                                    (define-structure
-                                      define-expansion-accessors
-                                      define-expansion-constructors)
-                                    ((top) (top) (top))
-                                    ("l-*-47" "l-*-46" "l-*-45")))
-                                 (hygiene guile))
-                              mod-9496))))
-                  tmp-9452)
-                (syntax-violation
-                  #f
-                  "source expression failed to match any pattern"
-                  e-9448))))))
-      (global-extend-4293
-        'module-ref
-        '@@
-        (lambda (e-9589 r-9590 w-9591)
-          (letrec*
-            ((remodulate-9592
-               (lambda (x-9627 mod-9628)
-                 (if (pair? x-9627)
-                   (cons (remodulate-9592 (car x-9627) mod-9628)
-                         (remodulate-9592 (cdr x-9627) mod-9628))
-                   (if (if (vector? x-9627)
-                         (if (= (vector-length x-9627) 4)
-                           (eq? (vector-ref x-9627 0) 'syntax-object)
-                           #f)
-                         #f)
-                     (let ((expression-9642
-                             (remodulate-9592 (vector-ref x-9627 1) mod-9628))
-                           (wrap-9643 (vector-ref x-9627 2)))
-                       (vector
-                         'syntax-object
-                         expression-9642
-                         wrap-9643
-                         mod-9628))
-                     (if (vector? x-9627)
-                       (let ((n-9651 (vector-length x-9627)))
-                         (let ((v-9652 (make-vector n-9651)))
-                           (letrec*
-                             ((loop-9653
-                                (lambda (i-9700)
-                                  (if (= i-9700 n-9651)
-                                    v-9652
-                                    (begin
-                                      (vector-set!
-                                        v-9652
-                                        i-9700
-                                        (remodulate-9592
-                                          (vector-ref x-9627 i-9700)
-                                          mod-9628))
-                                      (loop-9653 (#{1+}# i-9700)))))))
-                             (loop-9653 0))))
-                       x-9627))))))
-            (let ((tmp-9594
-                    ($sc-dispatch e-9589 '(_ each-any any))))
-              (if (if tmp-9594
-                    (@apply
-                      (lambda (mod-9598 exp-9599)
-                        (and-map id?-4295 mod-9598))
-                      tmp-9594)
-                    #f)
-                (@apply
-                  (lambda (mod-9615 exp-9616)
-                    (let ((mod-9617
-                            (syntax->datum
-                              (cons '#(syntax-object
-                                       private
-                                       ((top)
-                                        #(ribcage
-                                          #(mod exp)
-                                          #((top) (top))
-                                          #("l-*-3634" "l-*-3635"))
-                                        #(ribcage
-                                          (remodulate)
-                                          ((top))
-                                          ("l-*-3607"))
-                                        #(ribcage
-                                          #(e r w)
-                                          #((top) (top) (top))
-                                          #("l-*-3604" "l-*-3605" "l-*-3606"))
-                                        #(ribcage
-                                          (lambda-var-list
-                                            gen-var
-                                            strip
-                                            expand-lambda-case
-                                            lambda*-formals
-                                            expand-simple-lambda
-                                            lambda-formals
-                                            ellipsis?
-                                            expand-void
-                                            eval-local-transformer
-                                            expand-local-syntax
-                                            expand-body
-                                            expand-macro
-                                            expand-application
-                                            expand-expr
-                                            expand
-                                            syntax-type
-                                            parse-when-list
-                                            expand-install-global
-                                            expand-top-sequence
-                                            expand-sequence
-                                            source-wrap
-                                            wrap
-                                            bound-id-member?
-                                            distinct-bound-ids?
-                                            valid-bound-ids?
-                                            bound-id=?
-                                            free-id=?
-                                            with-transformer-environment
-                                            transformer-environment
-                                            resolve-identifier
-                                            locally-bound-identifiers
-                                            id-var-name
-                                            same-marks?
-                                            join-marks
-                                            join-wraps
-                                            smart-append
-                                            make-binding-wrap
-                                            extend-ribcage!
-                                            make-empty-ribcage
-                                            new-mark
-                                            anti-mark
-                                            the-anti-mark
-                                            top-marked?
-                                            top-wrap
-                                            empty-wrap
-                                            set-ribcage-labels!
-                                            set-ribcage-marks!
-                                            set-ribcage-symnames!
-                                            ribcage-labels
-                                            ribcage-marks
-                                            ribcage-symnames
-                                            ribcage?
-                                            make-ribcage
-                                            gen-labels
-                                            gen-label
-                                            make-rename
-                                            rename-marks
-                                            rename-new
-                                            rename-old
-                                            subst-rename?
-                                            wrap-subst
-                                            wrap-marks
-                                            make-wrap
-                                            id-sym-name&marks
-                                            id-sym-name
-                                            id?
-                                            nonsymbol-id?
-                                            global-extend
-                                            lookup
-                                            macros-only-env
-                                            extend-var-env
-                                            extend-env
-                                            null-env
-                                            binding-value
-                                            binding-type
-                                            make-binding
-                                            arg-check
-                                            source-annotation
-                                            no-source
-                                            set-syntax-object-module!
-                                            set-syntax-object-wrap!
-                                            set-syntax-object-expression!
-                                            syntax-object-module
-                                            syntax-object-wrap
-                                            syntax-object-expression
-                                            syntax-object?
-                                            make-syntax-object
-                                            build-lexical-var
-                                            build-letrec
-                                            build-named-let
-                                            build-let
-                                            build-sequence
-                                            build-data
-                                            build-primref
-                                            build-lambda-case
-                                            build-case-lambda
-                                            build-simple-lambda
-                                            build-global-definition
-                                            build-global-assignment
-                                            build-global-reference
-                                            analyze-variable
-                                            build-lexical-assignment
-                                            build-lexical-reference
-                                            build-dynlet
-                                            build-conditional
-                                            build-application
-                                            build-void
-                                            maybe-name-value!
-                                            decorate-source
-                                            get-global-definition-hook
-                                            put-global-definition-hook
-                                            session-id
-                                            local-eval-hook
-                                            top-level-eval-hook
-                                            fx<
-                                            fx=
-                                            fx-
-                                            fx+
-                                            set-lambda-meta!
-                                            lambda-meta
-                                            lambda?
-                                            make-dynlet
-                                            make-letrec
-                                            make-let
-                                            make-lambda-case
-                                            make-lambda
-                                            make-sequence
-                                            make-application
-                                            make-conditional
-                                            make-toplevel-define
-                                            make-toplevel-set
-                                            make-toplevel-ref
-                                            make-module-set
-                                            make-module-ref
-                                            make-lexical-set
-                                            make-lexical-ref
-                                            make-primitive-ref
-                                            make-const
-                                            make-void)
-                                          ((top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top))
-                                          ("l-*-476"
-                                           "l-*-474"
-                                           "l-*-472"
-                                           "l-*-470"
-                                           "l-*-468"
-                                           "l-*-466"
-                                           "l-*-464"
-                                           "l-*-462"
-                                           "l-*-460"
-                                           "l-*-458"
-                                           "l-*-456"
-                                           "l-*-454"
-                                           "l-*-452"
-                                           "l-*-450"
-                                           "l-*-448"
-                                           "l-*-446"
-                                           "l-*-444"
-                                           "l-*-442"
-                                           "l-*-440"
-                                           "l-*-438"
-                                           "l-*-436"
-                                           "l-*-434"
-                                           "l-*-432"
-                                           "l-*-430"
-                                           "l-*-428"
-                                           "l-*-426"
-                                           "l-*-424"
-                                           "l-*-422"
-                                           "l-*-420"
-                                           "l-*-418"
-                                           "l-*-416"
-                                           "l-*-414"
-                                           "l-*-412"
-                                           "l-*-410"
-                                           "l-*-408"
-                                           "l-*-406"
-                                           "l-*-404"
-                                           "l-*-402"
-                                           "l-*-400"
-                                           "l-*-399"
-                                           "l-*-397"
-                                           "l-*-394"
-                                           "l-*-393"
-                                           "l-*-392"
-                                           "l-*-390"
-                                           "l-*-389"
-                                           "l-*-387"
-                                           "l-*-385"
-                                           "l-*-383"
-                                           "l-*-381"
-                                           "l-*-379"
-                                           "l-*-377"
-                                           "l-*-375"
-                                           "l-*-373"
-                                           "l-*-370"
-                                           "l-*-368"
-                                           "l-*-367"
-                                           "l-*-365"
-                                           "l-*-363"
-                                           "l-*-361"
-                                           "l-*-359"
-                                           "l-*-358"
-                                           "l-*-357"
-                                           "l-*-356"
-                                           "l-*-354"
-                                           "l-*-353"
-                                           "l-*-350"
-                                           "l-*-348"
-                                           "l-*-346"
-                                           "l-*-344"
-                                           "l-*-342"
-                                           "l-*-340"
-                                           "l-*-338"
-                                           "l-*-337"
-                                           "l-*-336"
-                                           "l-*-334"
-                                           "l-*-332"
-                                           "l-*-331"
-                                           "l-*-328"
-                                           "l-*-327"
-                                           "l-*-325"
-                                           "l-*-323"
-                                           "l-*-321"
-                                           "l-*-319"
-                                           "l-*-317"
-                                           "l-*-315"
-                                           "l-*-313"
-                                           "l-*-311"
-                                           "l-*-309"
-                                           "l-*-306"
-                                           "l-*-304"
-                                           "l-*-302"
-                                           "l-*-300"
-                                           "l-*-298"
-                                           "l-*-296"
-                                           "l-*-294"
-                                           "l-*-292"
-                                           "l-*-290"
-                                           "l-*-288"
-                                           "l-*-286"
-                                           "l-*-284"
-                                           "l-*-282"
-                                           "l-*-280"
-                                           "l-*-278"
-                                           "l-*-276"
-                                           "l-*-274"
-                                           "l-*-272"
-                                           "l-*-270"
-                                           "l-*-268"
-                                           "l-*-266"
-                                           "l-*-264"
-                                           "l-*-262"
-                                           "l-*-260"
-                                           "l-*-258"
-                                           "l-*-256"
-                                           "l-*-255"
-                                           "l-*-254"
-                                           "l-*-253"
-                                           "l-*-252"
-                                           "l-*-250"
-                                           "l-*-248"
-                                           "l-*-246"
-                                           "l-*-243"
-                                           "l-*-241"
-                                           "l-*-239"
-                                           "l-*-237"
-                                           "l-*-235"
-                                           "l-*-233"
-                                           "l-*-231"
-                                           "l-*-229"
-                                           "l-*-227"
-                                           "l-*-225"
-                                           "l-*-223"
-                                           "l-*-221"
-                                           "l-*-219"
-                                           "l-*-217"
-                                           "l-*-215"
-                                           "l-*-213"
-                                           "l-*-211"
-                                           "l-*-209"))
-                                        #(ribcage
-                                          (define-structure
-                                            define-expansion-accessors
-                                            define-expansion-constructors)
-                                          ((top) (top) (top))
-                                          ("l-*-47" "l-*-46" "l-*-45")))
-                                       (hygiene guile))
-                                    mod-9615))))
-                      (values
-                        (remodulate-9592 exp-9616 mod-9617)
-                        r-9590
-                        w-9591
-                        (source-annotation-4288 exp-9616)
-                        mod-9617)))
-                  tmp-9594)
-                (syntax-violation
-                  #f
-                  "source expression failed to match any pattern"
-                  e-9589))))))
-      (global-extend-4293
-        'core
-        'if
-        (lambda (e-9801 r-9802 w-9803 s-9804 mod-9805)
-          (let ((tmp-9807 ($sc-dispatch e-9801 '(_ any any))))
-            (if tmp-9807
-              (@apply
-                (lambda (test-9811 then-9812)
-                  (build-conditional-4263
-                    s-9804
-                    (expand-4331 test-9811 r-9802 w-9803 mod-9805)
-                    (expand-4331 then-9812 r-9802 w-9803 mod-9805)
-                    (make-struct/no-tail
-                      (vector-ref %expanded-vtables 0)
-                      #f)))
-                tmp-9807)
-              (let ((tmp-10037
-                      ($sc-dispatch e-9801 '(_ any any any))))
-                (if tmp-10037
-                  (@apply
-                    (lambda (test-10041 then-10042 else-10043)
-                      (build-conditional-4263
-                        s-9804
-                        (expand-4331 test-10041 r-9802 w-9803 mod-9805)
-                        (expand-4331 then-10042 r-9802 w-9803 mod-9805)
-                        (expand-4331 else-10043 r-9802 w-9803 mod-9805)))
-                    tmp-10037)
-                  (syntax-violation
-                    #f
-                    "source expression failed to match any pattern"
-                    e-9801)))))))
-      (global-extend-4293
-        'core
-        'with-fluids
-        (lambda (e-10442 r-10443 w-10444 s-10445 mod-10446)
-          (let ((tmp-10448
-                  ($sc-dispatch
-                    e-10442
-                    '(_ #(each (any any)) any . each-any))))
-            (if tmp-10448
-              (@apply
-                (lambda (fluid-10452 val-10453 b-10454 b*-10455)
-                  (build-dynlet-4264
-                    s-10445
-                    (map (lambda (x-10536)
-                           (expand-4331 x-10536 r-10443 w-10444 mod-10446))
-                         fluid-10452)
-                    (map (lambda (x-10606)
-                           (expand-4331 x-10606 r-10443 w-10444 mod-10446))
-                         val-10453)
-                    (expand-body-4335
-                      (cons b-10454 b*-10455)
-                      (wrap-4324
-                        (begin
-                          (if (if s-10445
-                                (supports-source-properties? e-10442)
-                                #f)
-                            (set-source-properties! e-10442 s-10445))
-                          e-10442)
-                        w-10444
-                        mod-10446)
-                      r-10443
-                      w-10444
-                      mod-10446)))
-                tmp-10448)
-              (syntax-violation
-                #f
-                "source expression failed to match any pattern"
-                e-10442)))))
-      (module-define!
-        (current-module)
-        'begin
-        (make-syntax-transformer 'begin 'begin '()))
-      (module-define!
-        (current-module)
-        'define
-        (make-syntax-transformer 'define 'define '()))
-      (module-define!
-        (current-module)
-        'define-syntax
-        (make-syntax-transformer
-          'define-syntax
-          'define-syntax
-          '()))
-      (module-define!
-        (current-module)
-        'define-syntax-parameter
-        (make-syntax-transformer
-          'define-syntax-parameter
-          'define-syntax-parameter
-          '()))
-      (module-define!
-        (current-module)
-        'eval-when
-        (make-syntax-transformer
-          'eval-when
-          'eval-when
-          '()))
-      (global-extend-4293
-        'core
-        'syntax-case
-        (letrec*
-          ((convert-pattern-10974
-             (lambda (pattern-12571 keys-12572)
-               (letrec*
-                 ((cvt*-12573
-                    (lambda (p*-13197 n-13198 ids-13199)
-                      (if (not (pair? p*-13197))
-                        (cvt-12575 p*-13197 n-13198 ids-13199)
-                        (call-with-values
-                          (lambda ()
-                            (cvt*-12573 (cdr p*-13197) n-13198 ids-13199))
-                          (lambda (y-13202 ids-13203)
-                            (call-with-values
-                              (lambda ()
-                                (cvt-12575 (car p*-13197) n-13198 ids-13203))
-                              (lambda (x-13206 ids-13207)
-                                (values
-                                  (cons x-13206 y-13202)
-                                  ids-13207))))))))
-                  (v-reverse-12574
-                    (lambda (x-13208)
-                      (letrec*
-                        ((loop-13209
-                           (lambda (r-13289 x-13290)
-                             (if (not (pair? x-13290))
-                               (values r-13289 x-13290)
-                               (loop-13209
-                                 (cons (car x-13290) r-13289)
-                                 (cdr x-13290))))))
-                        (loop-13209 '() x-13208))))
-                  (cvt-12575
-                    (lambda (p-12578 n-12579 ids-12580)
-                      (if (if (symbol? p-12578)
-                            #t
-                            (if (if (vector? p-12578)
-                                  (if (= (vector-length p-12578) 4)
-                                    (eq? (vector-ref p-12578 0) 'syntax-object)
-                                    #f)
-                                  #f)
-                              (symbol? (vector-ref p-12578 1))
-                              #f))
-                        (if (bound-id-member?-4323 p-12578 keys-12572)
-                          (values (vector 'free-id p-12578) ids-12580)
-                          (if (if (eq? (if (if (vector? p-12578)
-                                             (if (= (vector-length p-12578) 4)
-                                               (eq? (vector-ref p-12578 0)
-                                                    'syntax-object)
-                                               #f)
-                                             #f)
-                                         (vector-ref p-12578 1)
-                                         p-12578)
-                                       (if (if (= (vector-length
-                                                    '#(syntax-object
-                                                       _
-                                                       ((top)
-                                                        #(ribcage () () ())
-                                                        #(ribcage
-                                                          #(p n ids)
-                                                          #((top) (top) (top))
-                                                          #("l-*-3735"
-                                                            "l-*-3736"
-                                                            "l-*-3737"))
-                                                        #(ribcage
-                                                          (cvt v-reverse cvt*)
-                                                          ((top) (top) (top))
-                                                          ("l-*-3708"
-                                                           "l-*-3706"
-                                                           "l-*-3704"))
-                                                        #(ribcage
-                                                          #(pattern keys)
-                                                          #((top) (top))
-                                                          #("l-*-3702"
-                                                            "l-*-3703"))
-                                                        #(ribcage
-                                                          (gen-syntax-case
-                                                            gen-clause
-                                                            build-dispatch-call
-                                                            convert-pattern)
-                                                          ((top)
-                                                           (top)
-                                                           (top)
-                                                           (top))
-                                                          ("l-*-3698"
-                                                           "l-*-3696"
-                                                           "l-*-3694"
-                                                           "l-*-3692"))
-                                                        #(ribcage
-                                                          (lambda-var-list
-                                                            gen-var
-                                                            strip
-                                                            expand-lambda-case
-                                                            lambda*-formals
-                                                            
expand-simple-lambda
-                                                            lambda-formals
-                                                            ellipsis?
-                                                            expand-void
-                                                            
eval-local-transformer
-                                                            expand-local-syntax
-                                                            expand-body
-                                                            expand-macro
-                                                            expand-application
-                                                            expand-expr
-                                                            expand
-                                                            syntax-type
-                                                            parse-when-list
-                                                            
expand-install-global
-                                                            expand-top-sequence
-                                                            expand-sequence
-                                                            source-wrap
-                                                            wrap
-                                                            bound-id-member?
-                                                            distinct-bound-ids?
-                                                            valid-bound-ids?
-                                                            bound-id=?
-                                                            free-id=?
-                                                            
with-transformer-environment
-                                                            
transformer-environment
-                                                            resolve-identifier
-                                                            
locally-bound-identifiers
-                                                            id-var-name
-                                                            same-marks?
-                                                            join-marks
-                                                            join-wraps
-                                                            smart-append
-                                                            make-binding-wrap
-                                                            extend-ribcage!
-                                                            make-empty-ribcage
-                                                            new-mark
-                                                            anti-mark
-                                                            the-anti-mark
-                                                            top-marked?
-                                                            top-wrap
-                                                            empty-wrap
-                                                            set-ribcage-labels!
-                                                            set-ribcage-marks!
-                                                            
set-ribcage-symnames!
-                                                            ribcage-labels
-                                                            ribcage-marks
-                                                            ribcage-symnames
-                                                            ribcage?
-                                                            make-ribcage
-                                                            gen-labels
-                                                            gen-label
-                                                            make-rename
-                                                            rename-marks
-                                                            rename-new
-                                                            rename-old
-                                                            subst-rename?
-                                                            wrap-subst
-                                                            wrap-marks
-                                                            make-wrap
-                                                            id-sym-name&marks
-                                                            id-sym-name
-                                                            id?
-                                                            nonsymbol-id?
-                                                            global-extend
-                                                            lookup
-                                                            macros-only-env
-                                                            extend-var-env
-                                                            extend-env
-                                                            null-env
-                                                            binding-value
-                                                            binding-type
-                                                            make-binding
-                                                            arg-check
-                                                            source-annotation
-                                                            no-source
-                                                            
set-syntax-object-module!
-                                                            
set-syntax-object-wrap!
-                                                            
set-syntax-object-expression!
-                                                            
syntax-object-module
-                                                            syntax-object-wrap
-                                                            
syntax-object-expression
-                                                            syntax-object?
-                                                            make-syntax-object
-                                                            build-lexical-var
-                                                            build-letrec
-                                                            build-named-let
-                                                            build-let
-                                                            build-sequence
-                                                            build-data
-                                                            build-primref
-                                                            build-lambda-case
-                                                            build-case-lambda
-                                                            build-simple-lambda
-                                                            
build-global-definition
-                                                            
build-global-assignment
-                                                            
build-global-reference
-                                                            analyze-variable
-                                                            
build-lexical-assignment
-                                                            
build-lexical-reference
-                                                            build-dynlet
-                                                            build-conditional
-                                                            build-application
-                                                            build-void
-                                                            maybe-name-value!
-                                                            decorate-source
-                                                            
get-global-definition-hook
-                                                            
put-global-definition-hook
-                                                            session-id
-                                                            local-eval-hook
-                                                            top-level-eval-hook
-                                                            fx<
-                                                            fx=
-                                                            fx-
-                                                            fx+
-                                                            set-lambda-meta!
-                                                            lambda-meta
-                                                            lambda?
-                                                            make-dynlet
-                                                            make-letrec
-                                                            make-let
-                                                            make-lambda-case
-                                                            make-lambda
-                                                            make-sequence
-                                                            make-application
-                                                            make-conditional
-                                                            
make-toplevel-define
-                                                            make-toplevel-set
-                                                            make-toplevel-ref
-                                                            make-module-set
-                                                            make-module-ref
-                                                            make-lexical-set
-                                                            make-lexical-ref
-                                                            make-primitive-ref
-                                                            make-const
-                                                            make-void)
-                                                          ((top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top))
-                                                          ("l-*-476"
-                                                           "l-*-474"
-                                                           "l-*-472"
-                                                           "l-*-470"
-                                                           "l-*-468"
-                                                           "l-*-466"
-                                                           "l-*-464"
-                                                           "l-*-462"
-                                                           "l-*-460"
-                                                           "l-*-458"
-                                                           "l-*-456"
-                                                           "l-*-454"
-                                                           "l-*-452"
-                                                           "l-*-450"
-                                                           "l-*-448"
-                                                           "l-*-446"
-                                                           "l-*-444"
-                                                           "l-*-442"
-                                                           "l-*-440"
-                                                           "l-*-438"
-                                                           "l-*-436"
-                                                           "l-*-434"
-                                                           "l-*-432"
-                                                           "l-*-430"
-                                                           "l-*-428"
-                                                           "l-*-426"
-                                                           "l-*-424"
-                                                           "l-*-422"
-                                                           "l-*-420"
-                                                           "l-*-418"
-                                                           "l-*-416"
-                                                           "l-*-414"
-                                                           "l-*-412"
-                                                           "l-*-410"
-                                                           "l-*-408"
-                                                           "l-*-406"
-                                                           "l-*-404"
-                                                           "l-*-402"
-                                                           "l-*-400"
-                                                           "l-*-399"
-                                                           "l-*-397"
-                                                           "l-*-394"
-                                                           "l-*-393"
-                                                           "l-*-392"
-                                                           "l-*-390"
-                                                           "l-*-389"
-                                                           "l-*-387"
-                                                           "l-*-385"
-                                                           "l-*-383"
-                                                           "l-*-381"
-                                                           "l-*-379"
-                                                           "l-*-377"
-                                                           "l-*-375"
-                                                           "l-*-373"
-                                                           "l-*-370"
-                                                           "l-*-368"
-                                                           "l-*-367"
-                                                           "l-*-365"
-                                                           "l-*-363"
-                                                           "l-*-361"
-                                                           "l-*-359"
-                                                           "l-*-358"
-                                                           "l-*-357"
-                                                           "l-*-356"
-                                                           "l-*-354"
-                                                           "l-*-353"
-                                                           "l-*-350"
-                                                           "l-*-348"
-                                                           "l-*-346"
-                                                           "l-*-344"
-                                                           "l-*-342"
-                                                           "l-*-340"
-                                                           "l-*-338"
-                                                           "l-*-337"
-                                                           "l-*-336"
-                                                           "l-*-334"
-                                                           "l-*-332"
-                                                           "l-*-331"
-                                                           "l-*-328"
-                                                           "l-*-327"
-                                                           "l-*-325"
-                                                           "l-*-323"
-                                                           "l-*-321"
-                                                           "l-*-319"
-                                                           "l-*-317"
-                                                           "l-*-315"
-                                                           "l-*-313"
-                                                           "l-*-311"
-                                                           "l-*-309"
-                                                           "l-*-306"
-                                                           "l-*-304"
-                                                           "l-*-302"
-                                                           "l-*-300"
-                                                           "l-*-298"
-                                                           "l-*-296"
-                                                           "l-*-294"
-                                                           "l-*-292"
-                                                           "l-*-290"
-                                                           "l-*-288"
-                                                           "l-*-286"
-                                                           "l-*-284"
-                                                           "l-*-282"
-                                                           "l-*-280"
-                                                           "l-*-278"
-                                                           "l-*-276"
-                                                           "l-*-274"
-                                                           "l-*-272"
-                                                           "l-*-270"
-                                                           "l-*-268"
-                                                           "l-*-266"
-                                                           "l-*-264"
-                                                           "l-*-262"
-                                                           "l-*-260"
-                                                           "l-*-258"
-                                                           "l-*-256"
-                                                           "l-*-255"
-                                                           "l-*-254"
-                                                           "l-*-253"
-                                                           "l-*-252"
-                                                           "l-*-250"
-                                                           "l-*-248"
-                                                           "l-*-246"
-                                                           "l-*-243"
-                                                           "l-*-241"
-                                                           "l-*-239"
-                                                           "l-*-237"
-                                                           "l-*-235"
-                                                           "l-*-233"
-                                                           "l-*-231"
-                                                           "l-*-229"
-                                                           "l-*-227"
-                                                           "l-*-225"
-                                                           "l-*-223"
-                                                           "l-*-221"
-                                                           "l-*-219"
-                                                           "l-*-217"
-                                                           "l-*-215"
-                                                           "l-*-213"
-                                                           "l-*-211"
-                                                           "l-*-209"))
-                                                        #(ribcage
-                                                          (define-structure
-                                                            
define-expansion-accessors
-                                                            
define-expansion-constructors)
-                                                          ((top) (top) (top))
-                                                          ("l-*-47"
-                                                           "l-*-46"
-                                                           "l-*-45")))
-                                                       (hygiene guile)))
-                                                  4)
-                                             #t
-                                             #f)
-                                         '_
-                                         '#(syntax-object
-                                            _
-                                            ((top)
-                                             #(ribcage () () ())
-                                             #(ribcage
-                                               #(p n ids)
-                                               #((top) (top) (top))
-                                               #("l-*-3735"
-                                                 "l-*-3736"
-                                                 "l-*-3737"))
-                                             #(ribcage
-                                               (cvt v-reverse cvt*)
-                                               ((top) (top) (top))
-                                               ("l-*-3708"
-                                                "l-*-3706"
-                                                "l-*-3704"))
-                                             #(ribcage
-                                               #(pattern keys)
-                                               #((top) (top))
-                                               #("l-*-3702" "l-*-3703"))
-                                             #(ribcage
-                                               (gen-syntax-case
-                                                 gen-clause
-                                                 build-dispatch-call
-                                                 convert-pattern)
-                                               ((top) (top) (top) (top))
-                                               ("l-*-3698"
-                                                "l-*-3696"
-                                                "l-*-3694"
-                                                "l-*-3692"))
-                                             #(ribcage
-                                               (lambda-var-list
-                                                 gen-var
-                                                 strip
-                                                 expand-lambda-case
-                                                 lambda*-formals
-                                                 expand-simple-lambda
-                                                 lambda-formals
-                                                 ellipsis?
-                                                 expand-void
-                                                 eval-local-transformer
-                                                 expand-local-syntax
-                                                 expand-body
-                                                 expand-macro
-                                                 expand-application
-                                                 expand-expr
-                                                 expand
-                                                 syntax-type
-                                                 parse-when-list
-                                                 expand-install-global
-                                                 expand-top-sequence
-                                                 expand-sequence
-                                                 source-wrap
-                                                 wrap
-                                                 bound-id-member?
-                                                 distinct-bound-ids?
-                                                 valid-bound-ids?
-                                                 bound-id=?
-                                                 free-id=?
-                                                 with-transformer-environment
-                                                 transformer-environment
-                                                 resolve-identifier
-                                                 locally-bound-identifiers
-                                                 id-var-name
-                                                 same-marks?
-                                                 join-marks
-                                                 join-wraps
-                                                 smart-append
-                                                 make-binding-wrap
-                                                 extend-ribcage!
-                                                 make-empty-ribcage
-                                                 new-mark
-                                                 anti-mark
-                                                 the-anti-mark
-                                                 top-marked?
-                                                 top-wrap
-                                                 empty-wrap
-                                                 set-ribcage-labels!
-                                                 set-ribcage-marks!
-                                                 set-ribcage-symnames!
-                                                 ribcage-labels
-                                                 ribcage-marks
-                                                 ribcage-symnames
-                                                 ribcage?
-                                                 make-ribcage
-                                                 gen-labels
-                                                 gen-label
-                                                 make-rename
-                                                 rename-marks
-                                                 rename-new
-                                                 rename-old
-                                                 subst-rename?
-                                                 wrap-subst
-                                                 wrap-marks
-                                                 make-wrap
-                                                 id-sym-name&marks
-                                                 id-sym-name
-                                                 id?
-                                                 nonsymbol-id?
-                                                 global-extend
-                                                 lookup
-                                                 macros-only-env
-                                                 extend-var-env
-                                                 extend-env
-                                                 null-env
-                                                 binding-value
-                                                 binding-type
-                                                 make-binding
-                                                 arg-check
-                                                 source-annotation
-                                                 no-source
-                                                 set-syntax-object-module!
-                                                 set-syntax-object-wrap!
-                                                 set-syntax-object-expression!
-                                                 syntax-object-module
-                                                 syntax-object-wrap
-                                                 syntax-object-expression
-                                                 syntax-object?
-                                                 make-syntax-object
-                                                 build-lexical-var
-                                                 build-letrec
-                                                 build-named-let
-                                                 build-let
-                                                 build-sequence
-                                                 build-data
-                                                 build-primref
-                                                 build-lambda-case
-                                                 build-case-lambda
-                                                 build-simple-lambda
-                                                 build-global-definition
-                                                 build-global-assignment
-                                                 build-global-reference
-                                                 analyze-variable
-                                                 build-lexical-assignment
-                                                 build-lexical-reference
-                                                 build-dynlet
-                                                 build-conditional
-                                                 build-application
-                                                 build-void
-                                                 maybe-name-value!
-                                                 decorate-source
-                                                 get-global-definition-hook
-                                                 put-global-definition-hook
-                                                 session-id
-                                                 local-eval-hook
-                                                 top-level-eval-hook
-                                                 fx<
-                                                 fx=
-                                                 fx-
-                                                 fx+
-                                                 set-lambda-meta!
-                                                 lambda-meta
-                                                 lambda?
-                                                 make-dynlet
-                                                 make-letrec
-                                                 make-let
-                                                 make-lambda-case
-                                                 make-lambda
-                                                 make-sequence
-                                                 make-application
-                                                 make-conditional
-                                                 make-toplevel-define
-                                                 make-toplevel-set
-                                                 make-toplevel-ref
-                                                 make-module-set
-                                                 make-module-ref
-                                                 make-lexical-set
-                                                 make-lexical-ref
-                                                 make-primitive-ref
-                                                 make-const
-                                                 make-void)
-                                               ((top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top))
-                                               ("l-*-476"
-                                                "l-*-474"
-                                                "l-*-472"
-                                                "l-*-470"
-                                                "l-*-468"
-                                                "l-*-466"
-                                                "l-*-464"
-                                                "l-*-462"
-                                                "l-*-460"
-                                                "l-*-458"
-                                                "l-*-456"
-                                                "l-*-454"
-                                                "l-*-452"
-                                                "l-*-450"
-                                                "l-*-448"
-                                                "l-*-446"
-                                                "l-*-444"
-                                                "l-*-442"
-                                                "l-*-440"
-                                                "l-*-438"
-                                                "l-*-436"
-                                                "l-*-434"
-                                                "l-*-432"
-                                                "l-*-430"
-                                                "l-*-428"
-                                                "l-*-426"
-                                                "l-*-424"
-                                                "l-*-422"
-                                                "l-*-420"
-                                                "l-*-418"
-                                                "l-*-416"
-                                                "l-*-414"
-                                                "l-*-412"
-                                                "l-*-410"
-                                                "l-*-408"
-                                                "l-*-406"
-                                                "l-*-404"
-                                                "l-*-402"
-                                                "l-*-400"
-                                                "l-*-399"
-                                                "l-*-397"
-                                                "l-*-394"
-                                                "l-*-393"
-                                                "l-*-392"
-                                                "l-*-390"
-                                                "l-*-389"
-                                                "l-*-387"
-                                                "l-*-385"
-                                                "l-*-383"
-                                                "l-*-381"
-                                                "l-*-379"
-                                                "l-*-377"
-                                                "l-*-375"
-                                                "l-*-373"
-                                                "l-*-370"
-                                                "l-*-368"
-                                                "l-*-367"
-                                                "l-*-365"
-                                                "l-*-363"
-                                                "l-*-361"
-                                                "l-*-359"
-                                                "l-*-358"
-                                                "l-*-357"
-                                                "l-*-356"
-                                                "l-*-354"
-                                                "l-*-353"
-                                                "l-*-350"
-                                                "l-*-348"
-                                                "l-*-346"
-                                                "l-*-344"
-                                                "l-*-342"
-                                                "l-*-340"
-                                                "l-*-338"
-                                                "l-*-337"
-                                                "l-*-336"
-                                                "l-*-334"
-                                                "l-*-332"
-                                                "l-*-331"
-                                                "l-*-328"
-                                                "l-*-327"
-                                                "l-*-325"
-                                                "l-*-323"
-                                                "l-*-321"
-                                                "l-*-319"
-                                                "l-*-317"
-                                                "l-*-315"
-                                                "l-*-313"
-                                                "l-*-311"
-                                                "l-*-309"
-                                                "l-*-306"
-                                                "l-*-304"
-                                                "l-*-302"
-                                                "l-*-300"
-                                                "l-*-298"
-                                                "l-*-296"
-                                                "l-*-294"
-                                                "l-*-292"
-                                                "l-*-290"
-                                                "l-*-288"
-                                                "l-*-286"
-                                                "l-*-284"
-                                                "l-*-282"
-                                                "l-*-280"
-                                                "l-*-278"
-                                                "l-*-276"
-                                                "l-*-274"
-                                                "l-*-272"
-                                                "l-*-270"
-                                                "l-*-268"
-                                                "l-*-266"
-                                                "l-*-264"
-                                                "l-*-262"
-                                                "l-*-260"
-                                                "l-*-258"
-                                                "l-*-256"
-                                                "l-*-255"
-                                                "l-*-254"
-                                                "l-*-253"
-                                                "l-*-252"
-                                                "l-*-250"
-                                                "l-*-248"
-                                                "l-*-246"
-                                                "l-*-243"
-                                                "l-*-241"
-                                                "l-*-239"
-                                                "l-*-237"
-                                                "l-*-235"
-                                                "l-*-233"
-                                                "l-*-231"
-                                                "l-*-229"
-                                                "l-*-227"
-                                                "l-*-225"
-                                                "l-*-223"
-                                                "l-*-221"
-                                                "l-*-219"
-                                                "l-*-217"
-                                                "l-*-215"
-                                                "l-*-213"
-                                                "l-*-211"
-                                                "l-*-209"))
-                                             #(ribcage
-                                               (define-structure
-                                                 define-expansion-accessors
-                                                 define-expansion-constructors)
-                                               ((top) (top) (top))
-                                               ("l-*-47" "l-*-46" "l-*-45")))
-                                            (hygiene guile))))
-                                (eq? (id-var-name-4314 p-12578 '(()))
-                                     (id-var-name-4314
-                                       '#(syntax-object
-                                          _
-                                          ((top)
-                                           #(ribcage () () ())
-                                           #(ribcage
-                                             #(p n ids)
-                                             #((top) (top) (top))
-                                             #("l-*-3735"
-                                               "l-*-3736"
-                                               "l-*-3737"))
-                                           #(ribcage
-                                             (cvt v-reverse cvt*)
-                                             ((top) (top) (top))
-                                             ("l-*-3708"
-                                              "l-*-3706"
-                                              "l-*-3704"))
-                                           #(ribcage
-                                             #(pattern keys)
-                                             #((top) (top))
-                                             #("l-*-3702" "l-*-3703"))
-                                           #(ribcage
-                                             (gen-syntax-case
-                                               gen-clause
-                                               build-dispatch-call
-                                               convert-pattern)
-                                             ((top) (top) (top) (top))
-                                             ("l-*-3698"
-                                              "l-*-3696"
-                                              "l-*-3694"
-                                              "l-*-3692"))
-                                           #(ribcage
-                                             (lambda-var-list
-                                               gen-var
-                                               strip
-                                               expand-lambda-case
-                                               lambda*-formals
-                                               expand-simple-lambda
-                                               lambda-formals
-                                               ellipsis?
-                                               expand-void
-                                               eval-local-transformer
-                                               expand-local-syntax
-                                               expand-body
-                                               expand-macro
-                                               expand-application
-                                               expand-expr
-                                               expand
-                                               syntax-type
-                                               parse-when-list
-                                               expand-install-global
-                                               expand-top-sequence
-                                               expand-sequence
-                                               source-wrap
-                                               wrap
-                                               bound-id-member?
-                                               distinct-bound-ids?
-                                               valid-bound-ids?
-                                               bound-id=?
-                                               free-id=?
-                                               with-transformer-environment
-                                               transformer-environment
-                                               resolve-identifier
-                                               locally-bound-identifiers
-                                               id-var-name
-                                               same-marks?
-                                               join-marks
-                                               join-wraps
-                                               smart-append
-                                               make-binding-wrap
-                                               extend-ribcage!
-                                               make-empty-ribcage
-                                               new-mark
-                                               anti-mark
-                                               the-anti-mark
-                                               top-marked?
-                                               top-wrap
-                                               empty-wrap
-                                               set-ribcage-labels!
-                                               set-ribcage-marks!
-                                               set-ribcage-symnames!
-                                               ribcage-labels
-                                               ribcage-marks
-                                               ribcage-symnames
-                                               ribcage?
-                                               make-ribcage
-                                               gen-labels
-                                               gen-label
-                                               make-rename
-                                               rename-marks
-                                               rename-new
-                                               rename-old
-                                               subst-rename?
-                                               wrap-subst
-                                               wrap-marks
-                                               make-wrap
-                                               id-sym-name&marks
-                                               id-sym-name
-                                               id?
-                                               nonsymbol-id?
-                                               global-extend
-                                               lookup
-                                               macros-only-env
-                                               extend-var-env
-                                               extend-env
-                                               null-env
-                                               binding-value
-                                               binding-type
-                                               make-binding
-                                               arg-check
-                                               source-annotation
-                                               no-source
-                                               set-syntax-object-module!
-                                               set-syntax-object-wrap!
-                                               set-syntax-object-expression!
-                                               syntax-object-module
-                                               syntax-object-wrap
-                                               syntax-object-expression
-                                               syntax-object?
-                                               make-syntax-object
-                                               build-lexical-var
-                                               build-letrec
-                                               build-named-let
-                                               build-let
-                                               build-sequence
-                                               build-data
-                                               build-primref
-                                               build-lambda-case
-                                               build-case-lambda
-                                               build-simple-lambda
-                                               build-global-definition
-                                               build-global-assignment
-                                               build-global-reference
-                                               analyze-variable
-                                               build-lexical-assignment
-                                               build-lexical-reference
-                                               build-dynlet
-                                               build-conditional
-                                               build-application
-                                               build-void
-                                               maybe-name-value!
-                                               decorate-source
-                                               get-global-definition-hook
-                                               put-global-definition-hook
-                                               session-id
-                                               local-eval-hook
-                                               top-level-eval-hook
-                                               fx<
-                                               fx=
-                                               fx-
-                                               fx+
-                                               set-lambda-meta!
-                                               lambda-meta
-                                               lambda?
-                                               make-dynlet
-                                               make-letrec
-                                               make-let
-                                               make-lambda-case
-                                               make-lambda
-                                               make-sequence
-                                               make-application
-                                               make-conditional
-                                               make-toplevel-define
-                                               make-toplevel-set
-                                               make-toplevel-ref
-                                               make-module-set
-                                               make-module-ref
-                                               make-lexical-set
-                                               make-lexical-ref
-                                               make-primitive-ref
-                                               make-const
-                                               make-void)
-                                             ((top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top))
-                                             ("l-*-476"
-                                              "l-*-474"
-                                              "l-*-472"
-                                              "l-*-470"
-                                              "l-*-468"
-                                              "l-*-466"
-                                              "l-*-464"
-                                              "l-*-462"
-                                              "l-*-460"
-                                              "l-*-458"
-                                              "l-*-456"
-                                              "l-*-454"
-                                              "l-*-452"
-                                              "l-*-450"
-                                              "l-*-448"
-                                              "l-*-446"
-                                              "l-*-444"
-                                              "l-*-442"
-                                              "l-*-440"
-                                              "l-*-438"
-                                              "l-*-436"
-                                              "l-*-434"
-                                              "l-*-432"
-                                              "l-*-430"
-                                              "l-*-428"
-                                              "l-*-426"
-                                              "l-*-424"
-                                              "l-*-422"
-                                              "l-*-420"
-                                              "l-*-418"
-                                              "l-*-416"
-                                              "l-*-414"
-                                              "l-*-412"
-                                              "l-*-410"
-                                              "l-*-408"
-                                              "l-*-406"
-                                              "l-*-404"
-                                              "l-*-402"
-                                              "l-*-400"
-                                              "l-*-399"
-                                              "l-*-397"
-                                              "l-*-394"
-                                              "l-*-393"
-                                              "l-*-392"
-                                              "l-*-390"
-                                              "l-*-389"
-                                              "l-*-387"
-                                              "l-*-385"
-                                              "l-*-383"
-                                              "l-*-381"
-                                              "l-*-379"
-                                              "l-*-377"
-                                              "l-*-375"
-                                              "l-*-373"
-                                              "l-*-370"
-                                              "l-*-368"
-                                              "l-*-367"
-                                              "l-*-365"
-                                              "l-*-363"
-                                              "l-*-361"
-                                              "l-*-359"
-                                              "l-*-358"
-                                              "l-*-357"
-                                              "l-*-356"
-                                              "l-*-354"
-                                              "l-*-353"
-                                              "l-*-350"
-                                              "l-*-348"
-                                              "l-*-346"
-                                              "l-*-344"
-                                              "l-*-342"
-                                              "l-*-340"
-                                              "l-*-338"
-                                              "l-*-337"
-                                              "l-*-336"
-                                              "l-*-334"
-                                              "l-*-332"
-                                              "l-*-331"
-                                              "l-*-328"
-                                              "l-*-327"
-                                              "l-*-325"
-                                              "l-*-323"
-                                              "l-*-321"
-                                              "l-*-319"
-                                              "l-*-317"
-                                              "l-*-315"
-                                              "l-*-313"
-                                              "l-*-311"
-                                              "l-*-309"
-                                              "l-*-306"
-                                              "l-*-304"
-                                              "l-*-302"
-                                              "l-*-300"
-                                              "l-*-298"
-                                              "l-*-296"
-                                              "l-*-294"
-                                              "l-*-292"
-                                              "l-*-290"
-                                              "l-*-288"
-                                              "l-*-286"
-                                              "l-*-284"
-                                              "l-*-282"
-                                              "l-*-280"
-                                              "l-*-278"
-                                              "l-*-276"
-                                              "l-*-274"
-                                              "l-*-272"
-                                              "l-*-270"
-                                              "l-*-268"
-                                              "l-*-266"
-                                              "l-*-264"
-                                              "l-*-262"
-                                              "l-*-260"
-                                              "l-*-258"
-                                              "l-*-256"
-                                              "l-*-255"
-                                              "l-*-254"
-                                              "l-*-253"
-                                              "l-*-252"
-                                              "l-*-250"
-                                              "l-*-248"
-                                              "l-*-246"
-                                              "l-*-243"
-                                              "l-*-241"
-                                              "l-*-239"
-                                              "l-*-237"
-                                              "l-*-235"
-                                              "l-*-233"
-                                              "l-*-231"
-                                              "l-*-229"
-                                              "l-*-227"
-                                              "l-*-225"
-                                              "l-*-223"
-                                              "l-*-221"
-                                              "l-*-219"
-                                              "l-*-217"
-                                              "l-*-215"
-                                              "l-*-213"
-                                              "l-*-211"
-                                              "l-*-209"))
-                                           #(ribcage
-                                             (define-structure
-                                               define-expansion-accessors
-                                               define-expansion-constructors)
-                                             ((top) (top) (top))
-                                             ("l-*-47" "l-*-46" "l-*-45")))
-                                          (hygiene guile))
-                                       '(())))
-                                #f)
-                            (values '_ ids-12580)
-                            (values
-                              'any
-                              (cons (cons p-12578 n-12579) ids-12580))))
-                        (let ((tmp-12900 ($sc-dispatch p-12578 '(any any))))
-                          (if (if tmp-12900
-                                (@apply
-                                  (lambda (x-12904 dots-12905)
-                                    (if (if (if (vector? dots-12905)
-                                              (if (= (vector-length dots-12905)
-                                                     4)
-                                                (eq? (vector-ref dots-12905 0)
-                                                     'syntax-object)
-                                                #f)
-                                              #f)
-                                          (symbol? (vector-ref dots-12905 1))
-                                          #f)
-                                      (if (eq? (if (if (vector? dots-12905)
-                                                     (if (= (vector-length
-                                                              dots-12905)
-                                                            4)
-                                                       (eq? (vector-ref
-                                                              dots-12905
-                                                              0)
-                                                            'syntax-object)
-                                                       #f)
-                                                     #f)
-                                                 (vector-ref dots-12905 1)
-                                                 dots-12905)
-                                               (if (if (= (vector-length
-                                                            '#(syntax-object
-                                                               ...
-                                                               ((top)
-                                                                #(ribcage
-                                                                  ()
-                                                                  ()
-                                                                  ())
-                                                                #(ribcage
-                                                                  ()
-                                                                  ()
-                                                                  ())
-                                                                #(ribcage
-                                                                  #(x)
-                                                                  #((top))
-                                                                  
#("l-*-2267"))
-                                                                #(ribcage
-                                                                  
(lambda-var-list
-                                                                    gen-var
-                                                                    strip
-                                                                    
expand-lambda-case
-                                                                    
lambda*-formals
-                                                                    
expand-simple-lambda
-                                                                    
lambda-formals
-                                                                    ellipsis?
-                                                                    expand-void
-                                                                    
eval-local-transformer
-                                                                    
expand-local-syntax
-                                                                    expand-body
-                                                                    
expand-macro
-                                                                    
expand-application
-                                                                    expand-expr
-                                                                    expand
-                                                                    syntax-type
-                                                                    
parse-when-list
-                                                                    
expand-install-global
-                                                                    
expand-top-sequence
-                                                                    
expand-sequence
-                                                                    source-wrap
-                                                                    wrap
-                                                                    
bound-id-member?
-                                                                    
distinct-bound-ids?
-                                                                    
valid-bound-ids?
-                                                                    bound-id=?
-                                                                    free-id=?
-                                                                    
with-transformer-environment
-                                                                    
transformer-environment
-                                                                    
resolve-identifier
-                                                                    
locally-bound-identifiers
-                                                                    id-var-name
-                                                                    same-marks?
-                                                                    join-marks
-                                                                    join-wraps
-                                                                    
smart-append
-                                                                    
make-binding-wrap
-                                                                    
extend-ribcage!
-                                                                    
make-empty-ribcage
-                                                                    new-mark
-                                                                    anti-mark
-                                                                    
the-anti-mark
-                                                                    top-marked?
-                                                                    top-wrap
-                                                                    empty-wrap
-                                                                    
set-ribcage-labels!
-                                                                    
set-ribcage-marks!
-                                                                    
set-ribcage-symnames!
-                                                                    
ribcage-labels
-                                                                    
ribcage-marks
-                                                                    
ribcage-symnames
-                                                                    ribcage?
-                                                                    
make-ribcage
-                                                                    gen-labels
-                                                                    gen-label
-                                                                    make-rename
-                                                                    
rename-marks
-                                                                    rename-new
-                                                                    rename-old
-                                                                    
subst-rename?
-                                                                    wrap-subst
-                                                                    wrap-marks
-                                                                    make-wrap
-                                                                    
id-sym-name&marks
-                                                                    id-sym-name
-                                                                    id?
-                                                                    
nonsymbol-id?
-                                                                    
global-extend
-                                                                    lookup
-                                                                    
macros-only-env
-                                                                    
extend-var-env
-                                                                    extend-env
-                                                                    null-env
-                                                                    
binding-value
-                                                                    
binding-type
-                                                                    
make-binding
-                                                                    arg-check
-                                                                    
source-annotation
-                                                                    no-source
-                                                                    
set-syntax-object-module!
-                                                                    
set-syntax-object-wrap!
-                                                                    
set-syntax-object-expression!
-                                                                    
syntax-object-module
-                                                                    
syntax-object-wrap
-                                                                    
syntax-object-expression
-                                                                    
syntax-object?
-                                                                    
make-syntax-object
-                                                                    
build-lexical-var
-                                                                    
build-letrec
-                                                                    
build-named-let
-                                                                    build-let
-                                                                    
build-sequence
-                                                                    build-data
-                                                                    
build-primref
-                                                                    
build-lambda-case
-                                                                    
build-case-lambda
-                                                                    
build-simple-lambda
-                                                                    
build-global-definition
-                                                                    
build-global-assignment
-                                                                    
build-global-reference
-                                                                    
analyze-variable
-                                                                    
build-lexical-assignment
-                                                                    
build-lexical-reference
-                                                                    
build-dynlet
-                                                                    
build-conditional
-                                                                    
build-application
-                                                                    build-void
-                                                                    
maybe-name-value!
-                                                                    
decorate-source
-                                                                    
get-global-definition-hook
-                                                                    
put-global-definition-hook
-                                                                    session-id
-                                                                    
local-eval-hook
-                                                                    
top-level-eval-hook
-                                                                    fx<
-                                                                    fx=
-                                                                    fx-
-                                                                    fx+
-                                                                    
set-lambda-meta!
-                                                                    lambda-meta
-                                                                    lambda?
-                                                                    make-dynlet
-                                                                    make-letrec
-                                                                    make-let
-                                                                    
make-lambda-case
-                                                                    make-lambda
-                                                                    
make-sequence
-                                                                    
make-application
-                                                                    
make-conditional
-                                                                    
make-toplevel-define
-                                                                    
make-toplevel-set
-                                                                    
make-toplevel-ref
-                                                                    
make-module-set
-                                                                    
make-module-ref
-                                                                    
make-lexical-set
-                                                                    
make-lexical-ref
-                                                                    
make-primitive-ref
-                                                                    make-const
-                                                                    make-void)
-                                                                  ((top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top))
-                                                                  ("l-*-476"
-                                                                   "l-*-474"
-                                                                   "l-*-472"
-                                                                   "l-*-470"
-                                                                   "l-*-468"
-                                                                   "l-*-466"
-                                                                   "l-*-464"
-                                                                   "l-*-462"
-                                                                   "l-*-460"
-                                                                   "l-*-458"
-                                                                   "l-*-456"
-                                                                   "l-*-454"
-                                                                   "l-*-452"
-                                                                   "l-*-450"
-                                                                   "l-*-448"
-                                                                   "l-*-446"
-                                                                   "l-*-444"
-                                                                   "l-*-442"
-                                                                   "l-*-440"
-                                                                   "l-*-438"
-                                                                   "l-*-436"
-                                                                   "l-*-434"
-                                                                   "l-*-432"
-                                                                   "l-*-430"
-                                                                   "l-*-428"
-                                                                   "l-*-426"
-                                                                   "l-*-424"
-                                                                   "l-*-422"
-                                                                   "l-*-420"
-                                                                   "l-*-418"
-                                                                   "l-*-416"
-                                                                   "l-*-414"
-                                                                   "l-*-412"
-                                                                   "l-*-410"
-                                                                   "l-*-408"
-                                                                   "l-*-406"
-                                                                   "l-*-404"
-                                                                   "l-*-402"
-                                                                   "l-*-400"
-                                                                   "l-*-399"
-                                                                   "l-*-397"
-                                                                   "l-*-394"
-                                                                   "l-*-393"
-                                                                   "l-*-392"
-                                                                   "l-*-390"
-                                                                   "l-*-389"
-                                                                   "l-*-387"
-                                                                   "l-*-385"
-                                                                   "l-*-383"
-                                                                   "l-*-381"
-                                                                   "l-*-379"
-                                                                   "l-*-377"
-                                                                   "l-*-375"
-                                                                   "l-*-373"
-                                                                   "l-*-370"
-                                                                   "l-*-368"
-                                                                   "l-*-367"
-                                                                   "l-*-365"
-                                                                   "l-*-363"
-                                                                   "l-*-361"
-                                                                   "l-*-359"
-                                                                   "l-*-358"
-                                                                   "l-*-357"
-                                                                   "l-*-356"
-                                                                   "l-*-354"
-                                                                   "l-*-353"
-                                                                   "l-*-350"
-                                                                   "l-*-348"
-                                                                   "l-*-346"
-                                                                   "l-*-344"
-                                                                   "l-*-342"
-                                                                   "l-*-340"
-                                                                   "l-*-338"
-                                                                   "l-*-337"
-                                                                   "l-*-336"
-                                                                   "l-*-334"
-                                                                   "l-*-332"
-                                                                   "l-*-331"
-                                                                   "l-*-328"
-                                                                   "l-*-327"
-                                                                   "l-*-325"
-                                                                   "l-*-323"
-                                                                   "l-*-321"
-                                                                   "l-*-319"
-                                                                   "l-*-317"
-                                                                   "l-*-315"
-                                                                   "l-*-313"
-                                                                   "l-*-311"
-                                                                   "l-*-309"
-                                                                   "l-*-306"
-                                                                   "l-*-304"
-                                                                   "l-*-302"
-                                                                   "l-*-300"
-                                                                   "l-*-298"
-                                                                   "l-*-296"
-                                                                   "l-*-294"
-                                                                   "l-*-292"
-                                                                   "l-*-290"
-                                                                   "l-*-288"
-                                                                   "l-*-286"
-                                                                   "l-*-284"
-                                                                   "l-*-282"
-                                                                   "l-*-280"
-                                                                   "l-*-278"
-                                                                   "l-*-276"
-                                                                   "l-*-274"
-                                                                   "l-*-272"
-                                                                   "l-*-270"
-                                                                   "l-*-268"
-                                                                   "l-*-266"
-                                                                   "l-*-264"
-                                                                   "l-*-262"
-                                                                   "l-*-260"
-                                                                   "l-*-258"
-                                                                   "l-*-256"
-                                                                   "l-*-255"
-                                                                   "l-*-254"
-                                                                   "l-*-253"
-                                                                   "l-*-252"
-                                                                   "l-*-250"
-                                                                   "l-*-248"
-                                                                   "l-*-246"
-                                                                   "l-*-243"
-                                                                   "l-*-241"
-                                                                   "l-*-239"
-                                                                   "l-*-237"
-                                                                   "l-*-235"
-                                                                   "l-*-233"
-                                                                   "l-*-231"
-                                                                   "l-*-229"
-                                                                   "l-*-227"
-                                                                   "l-*-225"
-                                                                   "l-*-223"
-                                                                   "l-*-221"
-                                                                   "l-*-219"
-                                                                   "l-*-217"
-                                                                   "l-*-215"
-                                                                   "l-*-213"
-                                                                   "l-*-211"
-                                                                   "l-*-209"))
-                                                                #(ribcage
-                                                                  
(define-structure
-                                                                    
define-expansion-accessors
-                                                                    
define-expansion-constructors)
-                                                                  ((top)
-                                                                   (top)
-                                                                   (top))
-                                                                  ("l-*-47"
-                                                                   "l-*-46"
-                                                                   "l-*-45")))
-                                                               (hygiene
-                                                                 guile)))
-                                                          4)
-                                                     #t
-                                                     #f)
-                                                 '...
-                                                 '#(syntax-object
-                                                    ...
-                                                    ((top)
-                                                     #(ribcage () () ())
-                                                     #(ribcage () () ())
-                                                     #(ribcage
-                                                       #(x)
-                                                       #((top))
-                                                       #("l-*-2267"))
-                                                     #(ribcage
-                                                       (lambda-var-list
-                                                         gen-var
-                                                         strip
-                                                         expand-lambda-case
-                                                         lambda*-formals
-                                                         expand-simple-lambda
-                                                         lambda-formals
-                                                         ellipsis?
-                                                         expand-void
-                                                         eval-local-transformer
-                                                         expand-local-syntax
-                                                         expand-body
-                                                         expand-macro
-                                                         expand-application
-                                                         expand-expr
-                                                         expand
-                                                         syntax-type
-                                                         parse-when-list
-                                                         expand-install-global
-                                                         expand-top-sequence
-                                                         expand-sequence
-                                                         source-wrap
-                                                         wrap
-                                                         bound-id-member?
-                                                         distinct-bound-ids?
-                                                         valid-bound-ids?
-                                                         bound-id=?
-                                                         free-id=?
-                                                         
with-transformer-environment
-                                                         
transformer-environment
-                                                         resolve-identifier
-                                                         
locally-bound-identifiers
-                                                         id-var-name
-                                                         same-marks?
-                                                         join-marks
-                                                         join-wraps
-                                                         smart-append
-                                                         make-binding-wrap
-                                                         extend-ribcage!
-                                                         make-empty-ribcage
-                                                         new-mark
-                                                         anti-mark
-                                                         the-anti-mark
-                                                         top-marked?
-                                                         top-wrap
-                                                         empty-wrap
-                                                         set-ribcage-labels!
-                                                         set-ribcage-marks!
-                                                         set-ribcage-symnames!
-                                                         ribcage-labels
-                                                         ribcage-marks
-                                                         ribcage-symnames
-                                                         ribcage?
-                                                         make-ribcage
-                                                         gen-labels
-                                                         gen-label
-                                                         make-rename
-                                                         rename-marks
-                                                         rename-new
-                                                         rename-old
-                                                         subst-rename?
-                                                         wrap-subst
-                                                         wrap-marks
-                                                         make-wrap
-                                                         id-sym-name&marks
-                                                         id-sym-name
-                                                         id?
-                                                         nonsymbol-id?
-                                                         global-extend
-                                                         lookup
-                                                         macros-only-env
-                                                         extend-var-env
-                                                         extend-env
-                                                         null-env
-                                                         binding-value
-                                                         binding-type
-                                                         make-binding
-                                                         arg-check
-                                                         source-annotation
-                                                         no-source
-                                                         
set-syntax-object-module!
-                                                         
set-syntax-object-wrap!
-                                                         
set-syntax-object-expression!
-                                                         syntax-object-module
-                                                         syntax-object-wrap
-                                                         
syntax-object-expression
-                                                         syntax-object?
-                                                         make-syntax-object
-                                                         build-lexical-var
-                                                         build-letrec
-                                                         build-named-let
-                                                         build-let
-                                                         build-sequence
-                                                         build-data
-                                                         build-primref
-                                                         build-lambda-case
-                                                         build-case-lambda
-                                                         build-simple-lambda
-                                                         
build-global-definition
-                                                         
build-global-assignment
-                                                         build-global-reference
-                                                         analyze-variable
-                                                         
build-lexical-assignment
-                                                         
build-lexical-reference
-                                                         build-dynlet
-                                                         build-conditional
-                                                         build-application
-                                                         build-void
-                                                         maybe-name-value!
-                                                         decorate-source
-                                                         
get-global-definition-hook
-                                                         
put-global-definition-hook
-                                                         session-id
-                                                         local-eval-hook
-                                                         top-level-eval-hook
-                                                         fx<
-                                                         fx=
-                                                         fx-
-                                                         fx+
-                                                         set-lambda-meta!
-                                                         lambda-meta
-                                                         lambda?
-                                                         make-dynlet
-                                                         make-letrec
-                                                         make-let
-                                                         make-lambda-case
-                                                         make-lambda
-                                                         make-sequence
-                                                         make-application
-                                                         make-conditional
-                                                         make-toplevel-define
-                                                         make-toplevel-set
-                                                         make-toplevel-ref
-                                                         make-module-set
-                                                         make-module-ref
-                                                         make-lexical-set
-                                                         make-lexical-ref
-                                                         make-primitive-ref
-                                                         make-const
-                                                         make-void)
-                                                       ((top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top))
-                                                       ("l-*-476"
-                                                        "l-*-474"
-                                                        "l-*-472"
-                                                        "l-*-470"
-                                                        "l-*-468"
-                                                        "l-*-466"
-                                                        "l-*-464"
-                                                        "l-*-462"
-                                                        "l-*-460"
-                                                        "l-*-458"
-                                                        "l-*-456"
-                                                        "l-*-454"
-                                                        "l-*-452"
-                                                        "l-*-450"
-                                                        "l-*-448"
-                                                        "l-*-446"
-                                                        "l-*-444"
-                                                        "l-*-442"
-                                                        "l-*-440"
-                                                        "l-*-438"
-                                                        "l-*-436"
-                                                        "l-*-434"
-                                                        "l-*-432"
-                                                        "l-*-430"
-                                                        "l-*-428"
-                                                        "l-*-426"
-                                                        "l-*-424"
-                                                        "l-*-422"
-                                                        "l-*-420"
-                                                        "l-*-418"
-                                                        "l-*-416"
-                                                        "l-*-414"
-                                                        "l-*-412"
-                                                        "l-*-410"
-                                                        "l-*-408"
-                                                        "l-*-406"
-                                                        "l-*-404"
-                                                        "l-*-402"
-                                                        "l-*-400"
-                                                        "l-*-399"
-                                                        "l-*-397"
-                                                        "l-*-394"
-                                                        "l-*-393"
-                                                        "l-*-392"
-                                                        "l-*-390"
-                                                        "l-*-389"
-                                                        "l-*-387"
-                                                        "l-*-385"
-                                                        "l-*-383"
-                                                        "l-*-381"
-                                                        "l-*-379"
-                                                        "l-*-377"
-                                                        "l-*-375"
-                                                        "l-*-373"
-                                                        "l-*-370"
-                                                        "l-*-368"
-                                                        "l-*-367"
-                                                        "l-*-365"
-                                                        "l-*-363"
-                                                        "l-*-361"
-                                                        "l-*-359"
-                                                        "l-*-358"
-                                                        "l-*-357"
-                                                        "l-*-356"
-                                                        "l-*-354"
-                                                        "l-*-353"
-                                                        "l-*-350"
-                                                        "l-*-348"
-                                                        "l-*-346"
-                                                        "l-*-344"
-                                                        "l-*-342"
-                                                        "l-*-340"
-                                                        "l-*-338"
-                                                        "l-*-337"
-                                                        "l-*-336"
-                                                        "l-*-334"
-                                                        "l-*-332"
-                                                        "l-*-331"
-                                                        "l-*-328"
-                                                        "l-*-327"
-                                                        "l-*-325"
-                                                        "l-*-323"
-                                                        "l-*-321"
-                                                        "l-*-319"
-                                                        "l-*-317"
-                                                        "l-*-315"
-                                                        "l-*-313"
-                                                        "l-*-311"
-                                                        "l-*-309"
-                                                        "l-*-306"
-                                                        "l-*-304"
-                                                        "l-*-302"
-                                                        "l-*-300"
-                                                        "l-*-298"
-                                                        "l-*-296"
-                                                        "l-*-294"
-                                                        "l-*-292"
-                                                        "l-*-290"
-                                                        "l-*-288"
-                                                        "l-*-286"
-                                                        "l-*-284"
-                                                        "l-*-282"
-                                                        "l-*-280"
-                                                        "l-*-278"
-                                                        "l-*-276"
-                                                        "l-*-274"
-                                                        "l-*-272"
-                                                        "l-*-270"
-                                                        "l-*-268"
-                                                        "l-*-266"
-                                                        "l-*-264"
-                                                        "l-*-262"
-                                                        "l-*-260"
-                                                        "l-*-258"
-                                                        "l-*-256"
-                                                        "l-*-255"
-                                                        "l-*-254"
-                                                        "l-*-253"
-                                                        "l-*-252"
-                                                        "l-*-250"
-                                                        "l-*-248"
-                                                        "l-*-246"
-                                                        "l-*-243"
-                                                        "l-*-241"
-                                                        "l-*-239"
-                                                        "l-*-237"
-                                                        "l-*-235"
-                                                        "l-*-233"
-                                                        "l-*-231"
-                                                        "l-*-229"
-                                                        "l-*-227"
-                                                        "l-*-225"
-                                                        "l-*-223"
-                                                        "l-*-221"
-                                                        "l-*-219"
-                                                        "l-*-217"
-                                                        "l-*-215"
-                                                        "l-*-213"
-                                                        "l-*-211"
-                                                        "l-*-209"))
-                                                     #(ribcage
-                                                       (define-structure
-                                                         
define-expansion-accessors
-                                                         
define-expansion-constructors)
-                                                       ((top) (top) (top))
-                                                       ("l-*-47"
-                                                        "l-*-46"
-                                                        "l-*-45")))
-                                                    (hygiene guile))))
-                                        (eq? (id-var-name-4314
-                                               dots-12905
-                                               '(()))
-                                             (id-var-name-4314
-                                               '#(syntax-object
-                                                  ...
-                                                  ((top)
-                                                   #(ribcage () () ())
-                                                   #(ribcage () () ())
-                                                   #(ribcage
-                                                     #(x)
-                                                     #((top))
-                                                     #("l-*-2267"))
-                                                   #(ribcage
-                                                     (lambda-var-list
-                                                       gen-var
-                                                       strip
-                                                       expand-lambda-case
-                                                       lambda*-formals
-                                                       expand-simple-lambda
-                                                       lambda-formals
-                                                       ellipsis?
-                                                       expand-void
-                                                       eval-local-transformer
-                                                       expand-local-syntax
-                                                       expand-body
-                                                       expand-macro
-                                                       expand-application
-                                                       expand-expr
-                                                       expand
-                                                       syntax-type
-                                                       parse-when-list
-                                                       expand-install-global
-                                                       expand-top-sequence
-                                                       expand-sequence
-                                                       source-wrap
-                                                       wrap
-                                                       bound-id-member?
-                                                       distinct-bound-ids?
-                                                       valid-bound-ids?
-                                                       bound-id=?
-                                                       free-id=?
-                                                       
with-transformer-environment
-                                                       transformer-environment
-                                                       resolve-identifier
-                                                       
locally-bound-identifiers
-                                                       id-var-name
-                                                       same-marks?
-                                                       join-marks
-                                                       join-wraps
-                                                       smart-append
-                                                       make-binding-wrap
-                                                       extend-ribcage!
-                                                       make-empty-ribcage
-                                                       new-mark
-                                                       anti-mark
-                                                       the-anti-mark
-                                                       top-marked?
-                                                       top-wrap
-                                                       empty-wrap
-                                                       set-ribcage-labels!
-                                                       set-ribcage-marks!
-                                                       set-ribcage-symnames!
-                                                       ribcage-labels
-                                                       ribcage-marks
-                                                       ribcage-symnames
-                                                       ribcage?
-                                                       make-ribcage
-                                                       gen-labels
-                                                       gen-label
-                                                       make-rename
-                                                       rename-marks
-                                                       rename-new
-                                                       rename-old
-                                                       subst-rename?
-                                                       wrap-subst
-                                                       wrap-marks
-                                                       make-wrap
-                                                       id-sym-name&marks
-                                                       id-sym-name
-                                                       id?
-                                                       nonsymbol-id?
-                                                       global-extend
-                                                       lookup
-                                                       macros-only-env
-                                                       extend-var-env
-                                                       extend-env
-                                                       null-env
-                                                       binding-value
-                                                       binding-type
-                                                       make-binding
-                                                       arg-check
-                                                       source-annotation
-                                                       no-source
-                                                       
set-syntax-object-module!
-                                                       set-syntax-object-wrap!
-                                                       
set-syntax-object-expression!
-                                                       syntax-object-module
-                                                       syntax-object-wrap
-                                                       syntax-object-expression
-                                                       syntax-object?
-                                                       make-syntax-object
-                                                       build-lexical-var
-                                                       build-letrec
-                                                       build-named-let
-                                                       build-let
-                                                       build-sequence
-                                                       build-data
-                                                       build-primref
-                                                       build-lambda-case
-                                                       build-case-lambda
-                                                       build-simple-lambda
-                                                       build-global-definition
-                                                       build-global-assignment
-                                                       build-global-reference
-                                                       analyze-variable
-                                                       build-lexical-assignment
-                                                       build-lexical-reference
-                                                       build-dynlet
-                                                       build-conditional
-                                                       build-application
-                                                       build-void
-                                                       maybe-name-value!
-                                                       decorate-source
-                                                       
get-global-definition-hook
-                                                       
put-global-definition-hook
-                                                       session-id
-                                                       local-eval-hook
-                                                       top-level-eval-hook
-                                                       fx<
-                                                       fx=
-                                                       fx-
-                                                       fx+
-                                                       set-lambda-meta!
-                                                       lambda-meta
-                                                       lambda?
-                                                       make-dynlet
-                                                       make-letrec
-                                                       make-let
-                                                       make-lambda-case
-                                                       make-lambda
-                                                       make-sequence
-                                                       make-application
-                                                       make-conditional
-                                                       make-toplevel-define
-                                                       make-toplevel-set
-                                                       make-toplevel-ref
-                                                       make-module-set
-                                                       make-module-ref
-                                                       make-lexical-set
-                                                       make-lexical-ref
-                                                       make-primitive-ref
-                                                       make-const
-                                                       make-void)
-                                                     ((top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top))
-                                                     ("l-*-476"
-                                                      "l-*-474"
-                                                      "l-*-472"
-                                                      "l-*-470"
-                                                      "l-*-468"
-                                                      "l-*-466"
-                                                      "l-*-464"
-                                                      "l-*-462"
-                                                      "l-*-460"
-                                                      "l-*-458"
-                                                      "l-*-456"
-                                                      "l-*-454"
-                                                      "l-*-452"
-                                                      "l-*-450"
-                                                      "l-*-448"
-                                                      "l-*-446"
-                                                      "l-*-444"
-                                                      "l-*-442"
-                                                      "l-*-440"
-                                                      "l-*-438"
-                                                      "l-*-436"
-                                                      "l-*-434"
-                                                      "l-*-432"
-                                                      "l-*-430"
-                                                      "l-*-428"
-                                                      "l-*-426"
-                                                      "l-*-424"
-                                                      "l-*-422"
-                                                      "l-*-420"
-                                                      "l-*-418"
-                                                      "l-*-416"
-                                                      "l-*-414"
-                                                      "l-*-412"
-                                                      "l-*-410"
-                                                      "l-*-408"
-                                                      "l-*-406"
-                                                      "l-*-404"
-                                                      "l-*-402"
-                                                      "l-*-400"
-                                                      "l-*-399"
-                                                      "l-*-397"
-                                                      "l-*-394"
-                                                      "l-*-393"
-                                                      "l-*-392"
-                                                      "l-*-390"
-                                                      "l-*-389"
-                                                      "l-*-387"
-                                                      "l-*-385"
-                                                      "l-*-383"
-                                                      "l-*-381"
-                                                      "l-*-379"
-                                                      "l-*-377"
-                                                      "l-*-375"
-                                                      "l-*-373"
-                                                      "l-*-370"
-                                                      "l-*-368"
-                                                      "l-*-367"
-                                                      "l-*-365"
-                                                      "l-*-363"
-                                                      "l-*-361"
-                                                      "l-*-359"
-                                                      "l-*-358"
-                                                      "l-*-357"
-                                                      "l-*-356"
-                                                      "l-*-354"
-                                                      "l-*-353"
-                                                      "l-*-350"
-                                                      "l-*-348"
-                                                      "l-*-346"
-                                                      "l-*-344"
-                                                      "l-*-342"
-                                                      "l-*-340"
-                                                      "l-*-338"
-                                                      "l-*-337"
-                                                      "l-*-336"
-                                                      "l-*-334"
-                                                      "l-*-332"
-                                                      "l-*-331"
-                                                      "l-*-328"
-                                                      "l-*-327"
-                                                      "l-*-325"
-                                                      "l-*-323"
-                                                      "l-*-321"
-                                                      "l-*-319"
-                                                      "l-*-317"
-                                                      "l-*-315"
-                                                      "l-*-313"
-                                                      "l-*-311"
-                                                      "l-*-309"
-                                                      "l-*-306"
-                                                      "l-*-304"
-                                                      "l-*-302"
-                                                      "l-*-300"
-                                                      "l-*-298"
-                                                      "l-*-296"
-                                                      "l-*-294"
-                                                      "l-*-292"
-                                                      "l-*-290"
-                                                      "l-*-288"
-                                                      "l-*-286"
-                                                      "l-*-284"
-                                                      "l-*-282"
-                                                      "l-*-280"
-                                                      "l-*-278"
-                                                      "l-*-276"
-                                                      "l-*-274"
-                                                      "l-*-272"
-                                                      "l-*-270"
-                                                      "l-*-268"
-                                                      "l-*-266"
-                                                      "l-*-264"
-                                                      "l-*-262"
-                                                      "l-*-260"
-                                                      "l-*-258"
-                                                      "l-*-256"
-                                                      "l-*-255"
-                                                      "l-*-254"
-                                                      "l-*-253"
-                                                      "l-*-252"
-                                                      "l-*-250"
-                                                      "l-*-248"
-                                                      "l-*-246"
-                                                      "l-*-243"
-                                                      "l-*-241"
-                                                      "l-*-239"
-                                                      "l-*-237"
-                                                      "l-*-235"
-                                                      "l-*-233"
-                                                      "l-*-231"
-                                                      "l-*-229"
-                                                      "l-*-227"
-                                                      "l-*-225"
-                                                      "l-*-223"
-                                                      "l-*-221"
-                                                      "l-*-219"
-                                                      "l-*-217"
-                                                      "l-*-215"
-                                                      "l-*-213"
-                                                      "l-*-211"
-                                                      "l-*-209"))
-                                                   #(ribcage
-                                                     (define-structure
-                                                       
define-expansion-accessors
-                                                       
define-expansion-constructors)
-                                                     ((top) (top) (top))
-                                                     ("l-*-47"
-                                                      "l-*-46"
-                                                      "l-*-45")))
-                                                  (hygiene guile))
-                                               '(())))
-                                        #f)
-                                      #f))
-                                  tmp-12900)
-                                #f)
-                            (@apply
-                              (lambda (x-13005 dots-13006)
-                                (call-with-values
-                                  (lambda ()
-                                    (cvt-12575
-                                      x-13005
-                                      (#{1+}# n-12579)
-                                      ids-12580))
-                                  (lambda (p-13007 ids-13008)
-                                    (values
-                                      (if (eq? p-13007 'any)
-                                        'each-any
-                                        (vector 'each p-13007))
-                                      ids-13008))))
-                              tmp-12900)
-                            (let ((tmp-13009
-                                    ($sc-dispatch p-12578 '(any any . any))))
-                              (if (if tmp-13009
-                                    (@apply
-                                      (lambda (x-13013 dots-13014 ys-13015)
-                                        (if (if (if (vector? dots-13014)
-                                                  (if (= (vector-length
-                                                           dots-13014)
-                                                         4)
-                                                    (eq? (vector-ref
-                                                           dots-13014
-                                                           0)
-                                                         'syntax-object)
-                                                    #f)
-                                                  #f)
-                                              (symbol?
-                                                (vector-ref dots-13014 1))
-                                              #f)
-                                          (if (eq? (if (if (vector? dots-13014)
-                                                         (if (= (vector-length
-                                                                  dots-13014)
-                                                                4)
-                                                           (eq? (vector-ref
-                                                                  dots-13014
-                                                                  0)
-                                                                'syntax-object)
-                                                           #f)
-                                                         #f)
-                                                     (vector-ref dots-13014 1)
-                                                     dots-13014)
-                                                   (if (if (= (vector-length
-                                                                
'#(syntax-object
-                                                                   ...
-                                                                   ((top)
-                                                                    #(ribcage
-                                                                      ()
-                                                                      ()
-                                                                      ())
-                                                                    #(ribcage
-                                                                      ()
-                                                                      ()
-                                                                      ())
-                                                                    #(ribcage
-                                                                      #(x)
-                                                                      #((top))
-                                                                      
#("l-*-2267"))
-                                                                    #(ribcage
-                                                                      
(lambda-var-list
-                                                                        gen-var
-                                                                        strip
-                                                                        
expand-lambda-case
-                                                                        
lambda*-formals
-                                                                        
expand-simple-lambda
-                                                                        
lambda-formals
-                                                                        
ellipsis?
-                                                                        
expand-void
-                                                                        
eval-local-transformer
-                                                                        
expand-local-syntax
-                                                                        
expand-body
-                                                                        
expand-macro
-                                                                        
expand-application
-                                                                        
expand-expr
-                                                                        expand
-                                                                        
syntax-type
-                                                                        
parse-when-list
-                                                                        
expand-install-global
-                                                                        
expand-top-sequence
-                                                                        
expand-sequence
-                                                                        
source-wrap
-                                                                        wrap
-                                                                        
bound-id-member?
-                                                                        
distinct-bound-ids?
-                                                                        
valid-bound-ids?
-                                                                        
bound-id=?
-                                                                        
free-id=?
-                                                                        
with-transformer-environment
-                                                                        
transformer-environment
-                                                                        
resolve-identifier
-                                                                        
locally-bound-identifiers
-                                                                        
id-var-name
-                                                                        
same-marks?
-                                                                        
join-marks
-                                                                        
join-wraps
-                                                                        
smart-append
-                                                                        
make-binding-wrap
-                                                                        
extend-ribcage!
-                                                                        
make-empty-ribcage
-                                                                        
new-mark
-                                                                        
anti-mark
-                                                                        
the-anti-mark
-                                                                        
top-marked?
-                                                                        
top-wrap
-                                                                        
empty-wrap
-                                                                        
set-ribcage-labels!
-                                                                        
set-ribcage-marks!
-                                                                        
set-ribcage-symnames!
-                                                                        
ribcage-labels
-                                                                        
ribcage-marks
-                                                                        
ribcage-symnames
-                                                                        
ribcage?
-                                                                        
make-ribcage
-                                                                        
gen-labels
-                                                                        
gen-label
-                                                                        
make-rename
-                                                                        
rename-marks
-                                                                        
rename-new
-                                                                        
rename-old
-                                                                        
subst-rename?
-                                                                        
wrap-subst
-                                                                        
wrap-marks
-                                                                        
make-wrap
-                                                                        
id-sym-name&marks
-                                                                        
id-sym-name
-                                                                        id?
-                                                                        
nonsymbol-id?
-                                                                        
global-extend
-                                                                        lookup
-                                                                        
macros-only-env
-                                                                        
extend-var-env
-                                                                        
extend-env
-                                                                        
null-env
-                                                                        
binding-value
-                                                                        
binding-type
-                                                                        
make-binding
-                                                                        
arg-check
-                                                                        
source-annotation
-                                                                        
no-source
-                                                                        
set-syntax-object-module!
-                                                                        
set-syntax-object-wrap!
-                                                                        
set-syntax-object-expression!
-                                                                        
syntax-object-module
-                                                                        
syntax-object-wrap
-                                                                        
syntax-object-expression
-                                                                        
syntax-object?
-                                                                        
make-syntax-object
-                                                                        
build-lexical-var
-                                                                        
build-letrec
-                                                                        
build-named-let
-                                                                        
build-let
-                                                                        
build-sequence
-                                                                        
build-data
-                                                                        
build-primref
-                                                                        
build-lambda-case
-                                                                        
build-case-lambda
-                                                                        
build-simple-lambda
-                                                                        
build-global-definition
-                                                                        
build-global-assignment
-                                                                        
build-global-reference
-                                                                        
analyze-variable
-                                                                        
build-lexical-assignment
-                                                                        
build-lexical-reference
-                                                                        
build-dynlet
-                                                                        
build-conditional
-                                                                        
build-application
-                                                                        
build-void
-                                                                        
maybe-name-value!
-                                                                        
decorate-source
-                                                                        
get-global-definition-hook
-                                                                        
put-global-definition-hook
-                                                                        
session-id
-                                                                        
local-eval-hook
-                                                                        
top-level-eval-hook
-                                                                        fx<
-                                                                        fx=
-                                                                        fx-
-                                                                        fx+
-                                                                        
set-lambda-meta!
-                                                                        
lambda-meta
-                                                                        lambda?
-                                                                        
make-dynlet
-                                                                        
make-letrec
-                                                                        
make-let
-                                                                        
make-lambda-case
-                                                                        
make-lambda
-                                                                        
make-sequence
-                                                                        
make-application
-                                                                        
make-conditional
-                                                                        
make-toplevel-define
-                                                                        
make-toplevel-set
-                                                                        
make-toplevel-ref
-                                                                        
make-module-set
-                                                                        
make-module-ref
-                                                                        
make-lexical-set
-                                                                        
make-lexical-ref
-                                                                        
make-primitive-ref
-                                                                        
make-const
-                                                                        
make-void)
-                                                                      ((top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top))
-                                                                      
("l-*-476"
-                                                                       
"l-*-474"
-                                                                       
"l-*-472"
-                                                                       
"l-*-470"
-                                                                       
"l-*-468"
-                                                                       
"l-*-466"
-                                                                       
"l-*-464"
-                                                                       
"l-*-462"
-                                                                       
"l-*-460"
-                                                                       
"l-*-458"
-                                                                       
"l-*-456"
-                                                                       
"l-*-454"
-                                                                       
"l-*-452"
-                                                                       
"l-*-450"
-                                                                       
"l-*-448"
-                                                                       
"l-*-446"
-                                                                       
"l-*-444"
-                                                                       
"l-*-442"
-                                                                       
"l-*-440"
-                                                                       
"l-*-438"
-                                                                       
"l-*-436"
-                                                                       
"l-*-434"
-                                                                       
"l-*-432"
-                                                                       
"l-*-430"
-                                                                       
"l-*-428"
-                                                                       
"l-*-426"
-                                                                       
"l-*-424"
-                                                                       
"l-*-422"
-                                                                       
"l-*-420"
-                                                                       
"l-*-418"
-                                                                       
"l-*-416"
-                                                                       
"l-*-414"
-                                                                       
"l-*-412"
-                                                                       
"l-*-410"
-                                                                       
"l-*-408"
-                                                                       
"l-*-406"
-                                                                       
"l-*-404"
-                                                                       
"l-*-402"
-                                                                       
"l-*-400"
-                                                                       
"l-*-399"
-                                                                       
"l-*-397"
-                                                                       
"l-*-394"
-                                                                       
"l-*-393"
-                                                                       
"l-*-392"
-                                                                       
"l-*-390"
-                                                                       
"l-*-389"
-                                                                       
"l-*-387"
-                                                                       
"l-*-385"
-                                                                       
"l-*-383"
-                                                                       
"l-*-381"
-                                                                       
"l-*-379"
-                                                                       
"l-*-377"
-                                                                       
"l-*-375"
-                                                                       
"l-*-373"
-                                                                       
"l-*-370"
-                                                                       
"l-*-368"
-                                                                       
"l-*-367"
-                                                                       
"l-*-365"
-                                                                       
"l-*-363"
-                                                                       
"l-*-361"
-                                                                       
"l-*-359"
-                                                                       
"l-*-358"
-                                                                       
"l-*-357"
-                                                                       
"l-*-356"
-                                                                       
"l-*-354"
-                                                                       
"l-*-353"
-                                                                       
"l-*-350"
-                                                                       
"l-*-348"
-                                                                       
"l-*-346"
-                                                                       
"l-*-344"
-                                                                       
"l-*-342"
-                                                                       
"l-*-340"
-                                                                       
"l-*-338"
-                                                                       
"l-*-337"
-                                                                       
"l-*-336"
-                                                                       
"l-*-334"
-                                                                       
"l-*-332"
-                                                                       
"l-*-331"
-                                                                       
"l-*-328"
-                                                                       
"l-*-327"
-                                                                       
"l-*-325"
-                                                                       
"l-*-323"
-                                                                       
"l-*-321"
-                                                                       
"l-*-319"
-                                                                       
"l-*-317"
-                                                                       
"l-*-315"
-                                                                       
"l-*-313"
-                                                                       
"l-*-311"
-                                                                       
"l-*-309"
-                                                                       
"l-*-306"
-                                                                       
"l-*-304"
-                                                                       
"l-*-302"
-                                                                       
"l-*-300"
-                                                                       
"l-*-298"
-                                                                       
"l-*-296"
-                                                                       
"l-*-294"
-                                                                       
"l-*-292"
-                                                                       
"l-*-290"
-                                                                       
"l-*-288"
-                                                                       
"l-*-286"
-                                                                       
"l-*-284"
-                                                                       
"l-*-282"
-                                                                       
"l-*-280"
-                                                                       
"l-*-278"
-                                                                       
"l-*-276"
-                                                                       
"l-*-274"
-                                                                       
"l-*-272"
-                                                                       
"l-*-270"
-                                                                       
"l-*-268"
-                                                                       
"l-*-266"
-                                                                       
"l-*-264"
-                                                                       
"l-*-262"
-                                                                       
"l-*-260"
-                                                                       
"l-*-258"
-                                                                       
"l-*-256"
-                                                                       
"l-*-255"
-                                                                       
"l-*-254"
-                                                                       
"l-*-253"
-                                                                       
"l-*-252"
-                                                                       
"l-*-250"
-                                                                       
"l-*-248"
-                                                                       
"l-*-246"
-                                                                       
"l-*-243"
-                                                                       
"l-*-241"
-                                                                       
"l-*-239"
-                                                                       
"l-*-237"
-                                                                       
"l-*-235"
-                                                                       
"l-*-233"
-                                                                       
"l-*-231"
-                                                                       
"l-*-229"
-                                                                       
"l-*-227"
-                                                                       
"l-*-225"
-                                                                       
"l-*-223"
-                                                                       
"l-*-221"
-                                                                       
"l-*-219"
-                                                                       
"l-*-217"
-                                                                       
"l-*-215"
-                                                                       
"l-*-213"
-                                                                       
"l-*-211"
-                                                                       
"l-*-209"))
-                                                                    #(ribcage
-                                                                      
(define-structure
-                                                                        
define-expansion-accessors
-                                                                        
define-expansion-constructors)
-                                                                      ((top)
-                                                                       (top)
-                                                                       (top))
-                                                                      ("l-*-47"
-                                                                       "l-*-46"
-                                                                       
"l-*-45")))
-                                                                   (hygiene
-                                                                     guile)))
-                                                              4)
-                                                         #t
-                                                         #f)
-                                                     '...
-                                                     '#(syntax-object
-                                                        ...
-                                                        ((top)
-                                                         #(ribcage () () ())
-                                                         #(ribcage () () ())
-                                                         #(ribcage
-                                                           #(x)
-                                                           #((top))
-                                                           #("l-*-2267"))
-                                                         #(ribcage
-                                                           (lambda-var-list
-                                                             gen-var
-                                                             strip
-                                                             expand-lambda-case
-                                                             lambda*-formals
-                                                             
expand-simple-lambda
-                                                             lambda-formals
-                                                             ellipsis?
-                                                             expand-void
-                                                             
eval-local-transformer
-                                                             
expand-local-syntax
-                                                             expand-body
-                                                             expand-macro
-                                                             expand-application
-                                                             expand-expr
-                                                             expand
-                                                             syntax-type
-                                                             parse-when-list
-                                                             
expand-install-global
-                                                             
expand-top-sequence
-                                                             expand-sequence
-                                                             source-wrap
-                                                             wrap
-                                                             bound-id-member?
-                                                             
distinct-bound-ids?
-                                                             valid-bound-ids?
-                                                             bound-id=?
-                                                             free-id=?
-                                                             
with-transformer-environment
-                                                             
transformer-environment
-                                                             resolve-identifier
-                                                             
locally-bound-identifiers
-                                                             id-var-name
-                                                             same-marks?
-                                                             join-marks
-                                                             join-wraps
-                                                             smart-append
-                                                             make-binding-wrap
-                                                             extend-ribcage!
-                                                             make-empty-ribcage
-                                                             new-mark
-                                                             anti-mark
-                                                             the-anti-mark
-                                                             top-marked?
-                                                             top-wrap
-                                                             empty-wrap
-                                                             
set-ribcage-labels!
-                                                             set-ribcage-marks!
-                                                             
set-ribcage-symnames!
-                                                             ribcage-labels
-                                                             ribcage-marks
-                                                             ribcage-symnames
-                                                             ribcage?
-                                                             make-ribcage
-                                                             gen-labels
-                                                             gen-label
-                                                             make-rename
-                                                             rename-marks
-                                                             rename-new
-                                                             rename-old
-                                                             subst-rename?
-                                                             wrap-subst
-                                                             wrap-marks
-                                                             make-wrap
-                                                             id-sym-name&marks
-                                                             id-sym-name
-                                                             id?
-                                                             nonsymbol-id?
-                                                             global-extend
-                                                             lookup
-                                                             macros-only-env
-                                                             extend-var-env
-                                                             extend-env
-                                                             null-env
-                                                             binding-value
-                                                             binding-type
-                                                             make-binding
-                                                             arg-check
-                                                             source-annotation
-                                                             no-source
-                                                             
set-syntax-object-module!
-                                                             
set-syntax-object-wrap!
-                                                             
set-syntax-object-expression!
-                                                             
syntax-object-module
-                                                             syntax-object-wrap
-                                                             
syntax-object-expression
-                                                             syntax-object?
-                                                             make-syntax-object
-                                                             build-lexical-var
-                                                             build-letrec
-                                                             build-named-let
-                                                             build-let
-                                                             build-sequence
-                                                             build-data
-                                                             build-primref
-                                                             build-lambda-case
-                                                             build-case-lambda
-                                                             
build-simple-lambda
-                                                             
build-global-definition
-                                                             
build-global-assignment
-                                                             
build-global-reference
-                                                             analyze-variable
-                                                             
build-lexical-assignment
-                                                             
build-lexical-reference
-                                                             build-dynlet
-                                                             build-conditional
-                                                             build-application
-                                                             build-void
-                                                             maybe-name-value!
-                                                             decorate-source
-                                                             
get-global-definition-hook
-                                                             
put-global-definition-hook
-                                                             session-id
-                                                             local-eval-hook
-                                                             
top-level-eval-hook
-                                                             fx<
-                                                             fx=
-                                                             fx-
-                                                             fx+
-                                                             set-lambda-meta!
-                                                             lambda-meta
-                                                             lambda?
-                                                             make-dynlet
-                                                             make-letrec
-                                                             make-let
-                                                             make-lambda-case
-                                                             make-lambda
-                                                             make-sequence
-                                                             make-application
-                                                             make-conditional
-                                                             
make-toplevel-define
-                                                             make-toplevel-set
-                                                             make-toplevel-ref
-                                                             make-module-set
-                                                             make-module-ref
-                                                             make-lexical-set
-                                                             make-lexical-ref
-                                                             make-primitive-ref
-                                                             make-const
-                                                             make-void)
-                                                           ((top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top)
-                                                            (top))
-                                                           ("l-*-476"
-                                                            "l-*-474"
-                                                            "l-*-472"
-                                                            "l-*-470"
-                                                            "l-*-468"
-                                                            "l-*-466"
-                                                            "l-*-464"
-                                                            "l-*-462"
-                                                            "l-*-460"
-                                                            "l-*-458"
-                                                            "l-*-456"
-                                                            "l-*-454"
-                                                            "l-*-452"
-                                                            "l-*-450"
-                                                            "l-*-448"
-                                                            "l-*-446"
-                                                            "l-*-444"
-                                                            "l-*-442"
-                                                            "l-*-440"
-                                                            "l-*-438"
-                                                            "l-*-436"
-                                                            "l-*-434"
-                                                            "l-*-432"
-                                                            "l-*-430"
-                                                            "l-*-428"
-                                                            "l-*-426"
-                                                            "l-*-424"
-                                                            "l-*-422"
-                                                            "l-*-420"
-                                                            "l-*-418"
-                                                            "l-*-416"
-                                                            "l-*-414"
-                                                            "l-*-412"
-                                                            "l-*-410"
-                                                            "l-*-408"
-                                                            "l-*-406"
-                                                            "l-*-404"
-                                                            "l-*-402"
-                                                            "l-*-400"
-                                                            "l-*-399"
-                                                            "l-*-397"
-                                                            "l-*-394"
-                                                            "l-*-393"
-                                                            "l-*-392"
-                                                            "l-*-390"
-                                                            "l-*-389"
-                                                            "l-*-387"
-                                                            "l-*-385"
-                                                            "l-*-383"
-                                                            "l-*-381"
-                                                            "l-*-379"
-                                                            "l-*-377"
-                                                            "l-*-375"
-                                                            "l-*-373"
-                                                            "l-*-370"
-                                                            "l-*-368"
-                                                            "l-*-367"
-                                                            "l-*-365"
-                                                            "l-*-363"
-                                                            "l-*-361"
-                                                            "l-*-359"
-                                                            "l-*-358"
-                                                            "l-*-357"
-                                                            "l-*-356"
-                                                            "l-*-354"
-                                                            "l-*-353"
-                                                            "l-*-350"
-                                                            "l-*-348"
-                                                            "l-*-346"
-                                                            "l-*-344"
-                                                            "l-*-342"
-                                                            "l-*-340"
-                                                            "l-*-338"
-                                                            "l-*-337"
-                                                            "l-*-336"
-                                                            "l-*-334"
-                                                            "l-*-332"
-                                                            "l-*-331"
-                                                            "l-*-328"
-                                                            "l-*-327"
-                                                            "l-*-325"
-                                                            "l-*-323"
-                                                            "l-*-321"
-                                                            "l-*-319"
-                                                            "l-*-317"
-                                                            "l-*-315"
-                                                            "l-*-313"
-                                                            "l-*-311"
-                                                            "l-*-309"
-                                                            "l-*-306"
-                                                            "l-*-304"
-                                                            "l-*-302"
-                                                            "l-*-300"
-                                                            "l-*-298"
-                                                            "l-*-296"
-                                                            "l-*-294"
-                                                            "l-*-292"
-                                                            "l-*-290"
-                                                            "l-*-288"
-                                                            "l-*-286"
-                                                            "l-*-284"
-                                                            "l-*-282"
-                                                            "l-*-280"
-                                                            "l-*-278"
-                                                            "l-*-276"
-                                                            "l-*-274"
-                                                            "l-*-272"
-                                                            "l-*-270"
-                                                            "l-*-268"
-                                                            "l-*-266"
-                                                            "l-*-264"
-                                                            "l-*-262"
-                                                            "l-*-260"
-                                                            "l-*-258"
-                                                            "l-*-256"
-                                                            "l-*-255"
-                                                            "l-*-254"
-                                                            "l-*-253"
-                                                            "l-*-252"
-                                                            "l-*-250"
-                                                            "l-*-248"
-                                                            "l-*-246"
-                                                            "l-*-243"
-                                                            "l-*-241"
-                                                            "l-*-239"
-                                                            "l-*-237"
-                                                            "l-*-235"
-                                                            "l-*-233"
-                                                            "l-*-231"
-                                                            "l-*-229"
-                                                            "l-*-227"
-                                                            "l-*-225"
-                                                            "l-*-223"
-                                                            "l-*-221"
-                                                            "l-*-219"
-                                                            "l-*-217"
-                                                            "l-*-215"
-                                                            "l-*-213"
-                                                            "l-*-211"
-                                                            "l-*-209"))
-                                                         #(ribcage
-                                                           (define-structure
-                                                             
define-expansion-accessors
-                                                             
define-expansion-constructors)
-                                                           ((top) (top) (top))
-                                                           ("l-*-47"
-                                                            "l-*-46"
-                                                            "l-*-45")))
-                                                        (hygiene guile))))
-                                            (eq? (id-var-name-4314
-                                                   dots-13014
-                                                   '(()))
-                                                 (id-var-name-4314
-                                                   '#(syntax-object
-                                                      ...
-                                                      ((top)
-                                                       #(ribcage () () ())
-                                                       #(ribcage () () ())
-                                                       #(ribcage
-                                                         #(x)
-                                                         #((top))
-                                                         #("l-*-2267"))
-                                                       #(ribcage
-                                                         (lambda-var-list
-                                                           gen-var
-                                                           strip
-                                                           expand-lambda-case
-                                                           lambda*-formals
-                                                           expand-simple-lambda
-                                                           lambda-formals
-                                                           ellipsis?
-                                                           expand-void
-                                                           
eval-local-transformer
-                                                           expand-local-syntax
-                                                           expand-body
-                                                           expand-macro
-                                                           expand-application
-                                                           expand-expr
-                                                           expand
-                                                           syntax-type
-                                                           parse-when-list
-                                                           
expand-install-global
-                                                           expand-top-sequence
-                                                           expand-sequence
-                                                           source-wrap
-                                                           wrap
-                                                           bound-id-member?
-                                                           distinct-bound-ids?
-                                                           valid-bound-ids?
-                                                           bound-id=?
-                                                           free-id=?
-                                                           
with-transformer-environment
-                                                           
transformer-environment
-                                                           resolve-identifier
-                                                           
locally-bound-identifiers
-                                                           id-var-name
-                                                           same-marks?
-                                                           join-marks
-                                                           join-wraps
-                                                           smart-append
-                                                           make-binding-wrap
-                                                           extend-ribcage!
-                                                           make-empty-ribcage
-                                                           new-mark
-                                                           anti-mark
-                                                           the-anti-mark
-                                                           top-marked?
-                                                           top-wrap
-                                                           empty-wrap
-                                                           set-ribcage-labels!
-                                                           set-ribcage-marks!
-                                                           
set-ribcage-symnames!
-                                                           ribcage-labels
-                                                           ribcage-marks
-                                                           ribcage-symnames
-                                                           ribcage?
-                                                           make-ribcage
-                                                           gen-labels
-                                                           gen-label
-                                                           make-rename
-                                                           rename-marks
-                                                           rename-new
-                                                           rename-old
-                                                           subst-rename?
-                                                           wrap-subst
-                                                           wrap-marks
-                                                           make-wrap
-                                                           id-sym-name&marks
-                                                           id-sym-name
-                                                           id?
-                                                           nonsymbol-id?
-                                                           global-extend
-                                                           lookup
-                                                           macros-only-env
-                                                           extend-var-env
-                                                           extend-env
-                                                           null-env
-                                                           binding-value
-                                                           binding-type
-                                                           make-binding
-                                                           arg-check
-                                                           source-annotation
-                                                           no-source
-                                                           
set-syntax-object-module!
-                                                           
set-syntax-object-wrap!
-                                                           
set-syntax-object-expression!
-                                                           syntax-object-module
-                                                           syntax-object-wrap
-                                                           
syntax-object-expression
-                                                           syntax-object?
-                                                           make-syntax-object
-                                                           build-lexical-var
-                                                           build-letrec
-                                                           build-named-let
-                                                           build-let
-                                                           build-sequence
-                                                           build-data
-                                                           build-primref
-                                                           build-lambda-case
-                                                           build-case-lambda
-                                                           build-simple-lambda
-                                                           
build-global-definition
-                                                           
build-global-assignment
-                                                           
build-global-reference
-                                                           analyze-variable
-                                                           
build-lexical-assignment
-                                                           
build-lexical-reference
-                                                           build-dynlet
-                                                           build-conditional
-                                                           build-application
-                                                           build-void
-                                                           maybe-name-value!
-                                                           decorate-source
-                                                           
get-global-definition-hook
-                                                           
put-global-definition-hook
-                                                           session-id
-                                                           local-eval-hook
-                                                           top-level-eval-hook
-                                                           fx<
-                                                           fx=
-                                                           fx-
-                                                           fx+
-                                                           set-lambda-meta!
-                                                           lambda-meta
-                                                           lambda?
-                                                           make-dynlet
-                                                           make-letrec
-                                                           make-let
-                                                           make-lambda-case
-                                                           make-lambda
-                                                           make-sequence
-                                                           make-application
-                                                           make-conditional
-                                                           make-toplevel-define
-                                                           make-toplevel-set
-                                                           make-toplevel-ref
-                                                           make-module-set
-                                                           make-module-ref
-                                                           make-lexical-set
-                                                           make-lexical-ref
-                                                           make-primitive-ref
-                                                           make-const
-                                                           make-void)
-                                                         ((top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top))
-                                                         ("l-*-476"
-                                                          "l-*-474"
-                                                          "l-*-472"
-                                                          "l-*-470"
-                                                          "l-*-468"
-                                                          "l-*-466"
-                                                          "l-*-464"
-                                                          "l-*-462"
-                                                          "l-*-460"
-                                                          "l-*-458"
-                                                          "l-*-456"
-                                                          "l-*-454"
-                                                          "l-*-452"
-                                                          "l-*-450"
-                                                          "l-*-448"
-                                                          "l-*-446"
-                                                          "l-*-444"
-                                                          "l-*-442"
-                                                          "l-*-440"
-                                                          "l-*-438"
-                                                          "l-*-436"
-                                                          "l-*-434"
-                                                          "l-*-432"
-                                                          "l-*-430"
-                                                          "l-*-428"
-                                                          "l-*-426"
-                                                          "l-*-424"
-                                                          "l-*-422"
-                                                          "l-*-420"
-                                                          "l-*-418"
-                                                          "l-*-416"
-                                                          "l-*-414"
-                                                          "l-*-412"
-                                                          "l-*-410"
-                                                          "l-*-408"
-                                                          "l-*-406"
-                                                          "l-*-404"
-                                                          "l-*-402"
-                                                          "l-*-400"
-                                                          "l-*-399"
-                                                          "l-*-397"
-                                                          "l-*-394"
-                                                          "l-*-393"
-                                                          "l-*-392"
-                                                          "l-*-390"
-                                                          "l-*-389"
-                                                          "l-*-387"
-                                                          "l-*-385"
-                                                          "l-*-383"
-                                                          "l-*-381"
-                                                          "l-*-379"
-                                                          "l-*-377"
-                                                          "l-*-375"
-                                                          "l-*-373"
-                                                          "l-*-370"
-                                                          "l-*-368"
-                                                          "l-*-367"
-                                                          "l-*-365"
-                                                          "l-*-363"
-                                                          "l-*-361"
-                                                          "l-*-359"
-                                                          "l-*-358"
-                                                          "l-*-357"
-                                                          "l-*-356"
-                                                          "l-*-354"
-                                                          "l-*-353"
-                                                          "l-*-350"
-                                                          "l-*-348"
-                                                          "l-*-346"
-                                                          "l-*-344"
-                                                          "l-*-342"
-                                                          "l-*-340"
-                                                          "l-*-338"
-                                                          "l-*-337"
-                                                          "l-*-336"
-                                                          "l-*-334"
-                                                          "l-*-332"
-                                                          "l-*-331"
-                                                          "l-*-328"
-                                                          "l-*-327"
-                                                          "l-*-325"
-                                                          "l-*-323"
-                                                          "l-*-321"
-                                                          "l-*-319"
-                                                          "l-*-317"
-                                                          "l-*-315"
-                                                          "l-*-313"
-                                                          "l-*-311"
-                                                          "l-*-309"
-                                                          "l-*-306"
-                                                          "l-*-304"
-                                                          "l-*-302"
-                                                          "l-*-300"
-                                                          "l-*-298"
-                                                          "l-*-296"
-                                                          "l-*-294"
-                                                          "l-*-292"
-                                                          "l-*-290"
-                                                          "l-*-288"
-                                                          "l-*-286"
-                                                          "l-*-284"
-                                                          "l-*-282"
-                                                          "l-*-280"
-                                                          "l-*-278"
-                                                          "l-*-276"
-                                                          "l-*-274"
-                                                          "l-*-272"
-                                                          "l-*-270"
-                                                          "l-*-268"
-                                                          "l-*-266"
-                                                          "l-*-264"
-                                                          "l-*-262"
-                                                          "l-*-260"
-                                                          "l-*-258"
-                                                          "l-*-256"
-                                                          "l-*-255"
-                                                          "l-*-254"
-                                                          "l-*-253"
-                                                          "l-*-252"
-                                                          "l-*-250"
-                                                          "l-*-248"
-                                                          "l-*-246"
-                                                          "l-*-243"
-                                                          "l-*-241"
-                                                          "l-*-239"
-                                                          "l-*-237"
-                                                          "l-*-235"
-                                                          "l-*-233"
-                                                          "l-*-231"
-                                                          "l-*-229"
-                                                          "l-*-227"
-                                                          "l-*-225"
-                                                          "l-*-223"
-                                                          "l-*-221"
-                                                          "l-*-219"
-                                                          "l-*-217"
-                                                          "l-*-215"
-                                                          "l-*-213"
-                                                          "l-*-211"
-                                                          "l-*-209"))
-                                                       #(ribcage
-                                                         (define-structure
-                                                           
define-expansion-accessors
-                                                           
define-expansion-constructors)
-                                                         ((top) (top) (top))
-                                                         ("l-*-47"
-                                                          "l-*-46"
-                                                          "l-*-45")))
-                                                      (hygiene guile))
-                                                   '(())))
-                                            #f)
-                                          #f))
-                                      tmp-13009)
-                                    #f)
-                                (@apply
-                                  (lambda (x-13115 dots-13116 ys-13117)
-                                    (call-with-values
-                                      (lambda ()
-                                        (cvt*-12573
-                                          ys-13117
-                                          n-12579
-                                          ids-12580))
-                                      (lambda (ys-13120 ids-13121)
-                                        (call-with-values
-                                          (lambda ()
-                                            (cvt-12575
-                                              x-13115
-                                              (#{1+}# n-12579)
-                                              ids-13121))
-                                          (lambda (x-13122 ids-13123)
-                                            (call-with-values
-                                              (lambda ()
-                                                (v-reverse-12574 ys-13120))
-                                              (lambda (ys-13156 e-13157)
-                                                (values
-                                                  (vector
-                                                    'each+
-                                                    x-13122
-                                                    ys-13156
-                                                    e-13157)
-                                                  ids-13123))))))))
-                                  tmp-13009)
-                                (let ((tmp-13158
-                                        ($sc-dispatch p-12578 '(any . any))))
-                                  (if tmp-13158
-                                    (@apply
-                                      (lambda (x-13162 y-13163)
-                                        (call-with-values
-                                          (lambda ()
-                                            (cvt-12575
-                                              y-13163
-                                              n-12579
-                                              ids-12580))
-                                          (lambda (y-13164 ids-13165)
-                                            (call-with-values
-                                              (lambda ()
-                                                (cvt-12575
-                                                  x-13162
-                                                  n-12579
-                                                  ids-13165))
-                                              (lambda (x-13166 ids-13167)
-                                                (values
-                                                  (cons x-13166 y-13164)
-                                                  ids-13167))))))
-                                      tmp-13158)
-                                    (let ((tmp-13168
-                                            ($sc-dispatch p-12578 '())))
-                                      (if tmp-13168
-                                        (@apply
-                                          (lambda () (values '() ids-12580))
-                                          tmp-13168)
-                                        (let ((tmp-13172
-                                                ($sc-dispatch
-                                                  p-12578
-                                                  '#(vector each-any))))
-                                          (if tmp-13172
-                                            (@apply
-                                              (lambda (x-13176)
-                                                (call-with-values
-                                                  (lambda ()
-                                                    (cvt-12575
-                                                      x-13176
-                                                      n-12579
-                                                      ids-12580))
-                                                  (lambda (p-13177 ids-13178)
-                                                    (values
-                                                      (vector 'vector p-13177)
-                                                      ids-13178))))
-                                              tmp-13172)
-                                            (values
-                                              (vector
-                                                'atom
-                                                (strip-4344 p-12578 '(())))
-                                              ids-12580)))))))))))))))
-                 (cvt-12575 pattern-12571 0 '()))))
-           (build-dispatch-call-10975
-             (lambda (pvars-13291 exp-13292 y-13293 r-13294 mod-13295)
-               (let ((ids-13296 (map car pvars-13291)))
-                 (begin
-                   (map cdr pvars-13291)
-                   (let ((labels-13298 (gen-labels-4298 ids-13296))
-                         (new-vars-13299 (map gen-var-4345 ids-13296)))
-                     (build-application-4262
-                       #f
-                       (if (equal? (module-name (current-module)) '(guile))
-                         (make-struct/no-tail
-                           (vector-ref %expanded-vtables 7)
-                           #f
-                           'apply)
-                         (make-struct/no-tail
-                           (vector-ref %expanded-vtables 5)
-                           #f
-                           '(guile)
-                           'apply
-                           #f))
-                       (list (build-simple-lambda-4271
-                               #f
-                               (map syntax->datum ids-13296)
-                               #f
-                               new-vars-13299
-                               '()
-                               (expand-4331
-                                 exp-13292
-                                 (extend-env-4289
-                                   labels-13298
-                                   (map (lambda (var-13622 level-13623)
-                                          (cons 'syntax
-                                                (cons var-13622 level-13623)))
-                                        new-vars-13299
-                                        (map cdr pvars-13291))
-                                   r-13294)
-                                 (make-binding-wrap-4309
-                                   ids-13296
-                                   labels-13298
-                                   '(()))
-                                 mod-13295))
-                             y-13293)))))))
-           (gen-clause-10976
-             (lambda (x-11943
-                      keys-11944
-                      clauses-11945
-                      r-11946
-                      pat-11947
-                      fender-11948
-                      exp-11949
-                      mod-11950)
-               (call-with-values
-                 (lambda ()
-                   (convert-pattern-10974 pat-11947 keys-11944))
-                 (lambda (p-12105 pvars-12106)
-                   (if (not (distinct-bound-ids?-4322 (map car pvars-12106)))
-                     (syntax-violation
-                       'syntax-case
-                       "duplicate pattern variable"
-                       pat-11947)
-                     (if (not (and-map
-                                (lambda (x-12222)
-                                  (not (let ((x-12226 (car x-12222)))
-                                         (if (if (if (vector? x-12226)
-                                                   (if (= (vector-length
-                                                            x-12226)
-                                                          4)
-                                                     (eq? (vector-ref
-                                                            x-12226
-                                                            0)
-                                                          'syntax-object)
-                                                     #f)
-                                                   #f)
-                                               (symbol? (vector-ref x-12226 1))
-                                               #f)
-                                           (if (eq? (if (if (vector? x-12226)
-                                                          (if (= (vector-length
-                                                                   x-12226)
-                                                                 4)
-                                                            (eq? (vector-ref
-                                                                   x-12226
-                                                                   0)
-                                                                 
'syntax-object)
-                                                            #f)
-                                                          #f)
-                                                      (vector-ref x-12226 1)
-                                                      x-12226)
-                                                    (if (if (= (vector-length
-                                                                 
'#(syntax-object
-                                                                    ...
-                                                                    ((top)
-                                                                     #(ribcage
-                                                                       ()
-                                                                       ()
-                                                                       ())
-                                                                     #(ribcage
-                                                                       ()
-                                                                       ()
-                                                                       ())
-                                                                     #(ribcage
-                                                                       #(x)
-                                                                       #((top))
-                                                                       
#("l-*-2267"))
-                                                                     #(ribcage
-                                                                       
(lambda-var-list
-                                                                         
gen-var
-                                                                         strip
-                                                                         
expand-lambda-case
-                                                                         
lambda*-formals
-                                                                         
expand-simple-lambda
-                                                                         
lambda-formals
-                                                                         
ellipsis?
-                                                                         
expand-void
-                                                                         
eval-local-transformer
-                                                                         
expand-local-syntax
-                                                                         
expand-body
-                                                                         
expand-macro
-                                                                         
expand-application
-                                                                         
expand-expr
-                                                                         expand
-                                                                         
syntax-type
-                                                                         
parse-when-list
-                                                                         
expand-install-global
-                                                                         
expand-top-sequence
-                                                                         
expand-sequence
-                                                                         
source-wrap
-                                                                         wrap
-                                                                         
bound-id-member?
-                                                                         
distinct-bound-ids?
-                                                                         
valid-bound-ids?
-                                                                         
bound-id=?
-                                                                         
free-id=?
-                                                                         
with-transformer-environment
-                                                                         
transformer-environment
-                                                                         
resolve-identifier
-                                                                         
locally-bound-identifiers
-                                                                         
id-var-name
-                                                                         
same-marks?
-                                                                         
join-marks
-                                                                         
join-wraps
-                                                                         
smart-append
-                                                                         
make-binding-wrap
-                                                                         
extend-ribcage!
-                                                                         
make-empty-ribcage
-                                                                         
new-mark
-                                                                         
anti-mark
-                                                                         
the-anti-mark
-                                                                         
top-marked?
-                                                                         
top-wrap
-                                                                         
empty-wrap
-                                                                         
set-ribcage-labels!
-                                                                         
set-ribcage-marks!
-                                                                         
set-ribcage-symnames!
-                                                                         
ribcage-labels
-                                                                         
ribcage-marks
-                                                                         
ribcage-symnames
-                                                                         
ribcage?
-                                                                         
make-ribcage
-                                                                         
gen-labels
-                                                                         
gen-label
-                                                                         
make-rename
-                                                                         
rename-marks
-                                                                         
rename-new
-                                                                         
rename-old
-                                                                         
subst-rename?
-                                                                         
wrap-subst
-                                                                         
wrap-marks
-                                                                         
make-wrap
-                                                                         
id-sym-name&marks
-                                                                         
id-sym-name
-                                                                         id?
-                                                                         
nonsymbol-id?
-                                                                         
global-extend
-                                                                         lookup
-                                                                         
macros-only-env
-                                                                         
extend-var-env
-                                                                         
extend-env
-                                                                         
null-env
-                                                                         
binding-value
-                                                                         
binding-type
-                                                                         
make-binding
-                                                                         
arg-check
-                                                                         
source-annotation
-                                                                         
no-source
-                                                                         
set-syntax-object-module!
-                                                                         
set-syntax-object-wrap!
-                                                                         
set-syntax-object-expression!
-                                                                         
syntax-object-module
-                                                                         
syntax-object-wrap
-                                                                         
syntax-object-expression
-                                                                         
syntax-object?
-                                                                         
make-syntax-object
-                                                                         
build-lexical-var
-                                                                         
build-letrec
-                                                                         
build-named-let
-                                                                         
build-let
-                                                                         
build-sequence
-                                                                         
build-data
-                                                                         
build-primref
-                                                                         
build-lambda-case
-                                                                         
build-case-lambda
-                                                                         
build-simple-lambda
-                                                                         
build-global-definition
-                                                                         
build-global-assignment
-                                                                         
build-global-reference
-                                                                         
analyze-variable
-                                                                         
build-lexical-assignment
-                                                                         
build-lexical-reference
-                                                                         
build-dynlet
-                                                                         
build-conditional
-                                                                         
build-application
-                                                                         
build-void
-                                                                         
maybe-name-value!
-                                                                         
decorate-source
-                                                                         
get-global-definition-hook
-                                                                         
put-global-definition-hook
-                                                                         
session-id
-                                                                         
local-eval-hook
-                                                                         
top-level-eval-hook
-                                                                         fx<
-                                                                         fx=
-                                                                         fx-
-                                                                         fx+
-                                                                         
set-lambda-meta!
-                                                                         
lambda-meta
-                                                                         
lambda?
-                                                                         
make-dynlet
-                                                                         
make-letrec
-                                                                         
make-let
-                                                                         
make-lambda-case
-                                                                         
make-lambda
-                                                                         
make-sequence
-                                                                         
make-application
-                                                                         
make-conditional
-                                                                         
make-toplevel-define
-                                                                         
make-toplevel-set
-                                                                         
make-toplevel-ref
-                                                                         
make-module-set
-                                                                         
make-module-ref
-                                                                         
make-lexical-set
-                                                                         
make-lexical-ref
-                                                                         
make-primitive-ref
-                                                                         
make-const
-                                                                         
make-void)
-                                                                       ((top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top))
-                                                                       
("l-*-476"
-                                                                        
"l-*-474"
-                                                                        
"l-*-472"
-                                                                        
"l-*-470"
-                                                                        
"l-*-468"
-                                                                        
"l-*-466"
-                                                                        
"l-*-464"
-                                                                        
"l-*-462"
-                                                                        
"l-*-460"
-                                                                        
"l-*-458"
-                                                                        
"l-*-456"
-                                                                        
"l-*-454"
-                                                                        
"l-*-452"
-                                                                        
"l-*-450"
-                                                                        
"l-*-448"
-                                                                        
"l-*-446"
-                                                                        
"l-*-444"
-                                                                        
"l-*-442"
-                                                                        
"l-*-440"
-                                                                        
"l-*-438"
-                                                                        
"l-*-436"
-                                                                        
"l-*-434"
-                                                                        
"l-*-432"
-                                                                        
"l-*-430"
-                                                                        
"l-*-428"
-                                                                        
"l-*-426"
-                                                                        
"l-*-424"
-                                                                        
"l-*-422"
-                                                                        
"l-*-420"
-                                                                        
"l-*-418"
-                                                                        
"l-*-416"
-                                                                        
"l-*-414"
-                                                                        
"l-*-412"
-                                                                        
"l-*-410"
-                                                                        
"l-*-408"
-                                                                        
"l-*-406"
-                                                                        
"l-*-404"
-                                                                        
"l-*-402"
-                                                                        
"l-*-400"
-                                                                        
"l-*-399"
-                                                                        
"l-*-397"
-                                                                        
"l-*-394"
-                                                                        
"l-*-393"
-                                                                        
"l-*-392"
-                                                                        
"l-*-390"
-                                                                        
"l-*-389"
-                                                                        
"l-*-387"
-                                                                        
"l-*-385"
-                                                                        
"l-*-383"
-                                                                        
"l-*-381"
-                                                                        
"l-*-379"
-                                                                        
"l-*-377"
-                                                                        
"l-*-375"
-                                                                        
"l-*-373"
-                                                                        
"l-*-370"
-                                                                        
"l-*-368"
-                                                                        
"l-*-367"
-                                                                        
"l-*-365"
-                                                                        
"l-*-363"
-                                                                        
"l-*-361"
-                                                                        
"l-*-359"
-                                                                        
"l-*-358"
-                                                                        
"l-*-357"
-                                                                        
"l-*-356"
-                                                                        
"l-*-354"
-                                                                        
"l-*-353"
-                                                                        
"l-*-350"
-                                                                        
"l-*-348"
-                                                                        
"l-*-346"
-                                                                        
"l-*-344"
-                                                                        
"l-*-342"
-                                                                        
"l-*-340"
-                                                                        
"l-*-338"
-                                                                        
"l-*-337"
-                                                                        
"l-*-336"
-                                                                        
"l-*-334"
-                                                                        
"l-*-332"
-                                                                        
"l-*-331"
-                                                                        
"l-*-328"
-                                                                        
"l-*-327"
-                                                                        
"l-*-325"
-                                                                        
"l-*-323"
-                                                                        
"l-*-321"
-                                                                        
"l-*-319"
-                                                                        
"l-*-317"
-                                                                        
"l-*-315"
-                                                                        
"l-*-313"
-                                                                        
"l-*-311"
-                                                                        
"l-*-309"
-                                                                        
"l-*-306"
-                                                                        
"l-*-304"
-                                                                        
"l-*-302"
-                                                                        
"l-*-300"
-                                                                        
"l-*-298"
-                                                                        
"l-*-296"
-                                                                        
"l-*-294"
-                                                                        
"l-*-292"
-                                                                        
"l-*-290"
-                                                                        
"l-*-288"
-                                                                        
"l-*-286"
-                                                                        
"l-*-284"
-                                                                        
"l-*-282"
-                                                                        
"l-*-280"
-                                                                        
"l-*-278"
-                                                                        
"l-*-276"
-                                                                        
"l-*-274"
-                                                                        
"l-*-272"
-                                                                        
"l-*-270"
-                                                                        
"l-*-268"
-                                                                        
"l-*-266"
-                                                                        
"l-*-264"
-                                                                        
"l-*-262"
-                                                                        
"l-*-260"
-                                                                        
"l-*-258"
-                                                                        
"l-*-256"
-                                                                        
"l-*-255"
-                                                                        
"l-*-254"
-                                                                        
"l-*-253"
-                                                                        
"l-*-252"
-                                                                        
"l-*-250"
-                                                                        
"l-*-248"
-                                                                        
"l-*-246"
-                                                                        
"l-*-243"
-                                                                        
"l-*-241"
-                                                                        
"l-*-239"
-                                                                        
"l-*-237"
-                                                                        
"l-*-235"
-                                                                        
"l-*-233"
-                                                                        
"l-*-231"
-                                                                        
"l-*-229"
-                                                                        
"l-*-227"
-                                                                        
"l-*-225"
-                                                                        
"l-*-223"
-                                                                        
"l-*-221"
-                                                                        
"l-*-219"
-                                                                        
"l-*-217"
-                                                                        
"l-*-215"
-                                                                        
"l-*-213"
-                                                                        
"l-*-211"
-                                                                        
"l-*-209"))
-                                                                     #(ribcage
-                                                                       
(define-structure
-                                                                         
define-expansion-accessors
-                                                                         
define-expansion-constructors)
-                                                                       ((top)
-                                                                        (top)
-                                                                        (top))
-                                                                       
("l-*-47"
-                                                                        
"l-*-46"
-                                                                        
"l-*-45")))
-                                                                    (hygiene
-                                                                      guile)))
-                                                               4)
-                                                          #t
-                                                          #f)
-                                                      '...
-                                                      '#(syntax-object
-                                                         ...
-                                                         ((top)
-                                                          #(ribcage () () ())
-                                                          #(ribcage () () ())
-                                                          #(ribcage
-                                                            #(x)
-                                                            #((top))
-                                                            #("l-*-2267"))
-                                                          #(ribcage
-                                                            (lambda-var-list
-                                                              gen-var
-                                                              strip
-                                                              
expand-lambda-case
-                                                              lambda*-formals
-                                                              
expand-simple-lambda
-                                                              lambda-formals
-                                                              ellipsis?
-                                                              expand-void
-                                                              
eval-local-transformer
-                                                              
expand-local-syntax
-                                                              expand-body
-                                                              expand-macro
-                                                              
expand-application
-                                                              expand-expr
-                                                              expand
-                                                              syntax-type
-                                                              parse-when-list
-                                                              
expand-install-global
-                                                              
expand-top-sequence
-                                                              expand-sequence
-                                                              source-wrap
-                                                              wrap
-                                                              bound-id-member?
-                                                              
distinct-bound-ids?
-                                                              valid-bound-ids?
-                                                              bound-id=?
-                                                              free-id=?
-                                                              
with-transformer-environment
-                                                              
transformer-environment
-                                                              
resolve-identifier
-                                                              
locally-bound-identifiers
-                                                              id-var-name
-                                                              same-marks?
-                                                              join-marks
-                                                              join-wraps
-                                                              smart-append
-                                                              make-binding-wrap
-                                                              extend-ribcage!
-                                                              
make-empty-ribcage
-                                                              new-mark
-                                                              anti-mark
-                                                              the-anti-mark
-                                                              top-marked?
-                                                              top-wrap
-                                                              empty-wrap
-                                                              
set-ribcage-labels!
-                                                              
set-ribcage-marks!
-                                                              
set-ribcage-symnames!
-                                                              ribcage-labels
-                                                              ribcage-marks
-                                                              ribcage-symnames
-                                                              ribcage?
-                                                              make-ribcage
-                                                              gen-labels
-                                                              gen-label
-                                                              make-rename
-                                                              rename-marks
-                                                              rename-new
-                                                              rename-old
-                                                              subst-rename?
-                                                              wrap-subst
-                                                              wrap-marks
-                                                              make-wrap
-                                                              id-sym-name&marks
-                                                              id-sym-name
-                                                              id?
-                                                              nonsymbol-id?
-                                                              global-extend
-                                                              lookup
-                                                              macros-only-env
-                                                              extend-var-env
-                                                              extend-env
-                                                              null-env
-                                                              binding-value
-                                                              binding-type
-                                                              make-binding
-                                                              arg-check
-                                                              source-annotation
-                                                              no-source
-                                                              
set-syntax-object-module!
-                                                              
set-syntax-object-wrap!
-                                                              
set-syntax-object-expression!
-                                                              
syntax-object-module
-                                                              
syntax-object-wrap
-                                                              
syntax-object-expression
-                                                              syntax-object?
-                                                              
make-syntax-object
-                                                              build-lexical-var
-                                                              build-letrec
-                                                              build-named-let
-                                                              build-let
-                                                              build-sequence
-                                                              build-data
-                                                              build-primref
-                                                              build-lambda-case
-                                                              build-case-lambda
-                                                              
build-simple-lambda
-                                                              
build-global-definition
-                                                              
build-global-assignment
-                                                              
build-global-reference
-                                                              analyze-variable
-                                                              
build-lexical-assignment
-                                                              
build-lexical-reference
-                                                              build-dynlet
-                                                              build-conditional
-                                                              build-application
-                                                              build-void
-                                                              maybe-name-value!
-                                                              decorate-source
-                                                              
get-global-definition-hook
-                                                              
put-global-definition-hook
-                                                              session-id
-                                                              local-eval-hook
-                                                              
top-level-eval-hook
-                                                              fx<
-                                                              fx=
-                                                              fx-
-                                                              fx+
-                                                              set-lambda-meta!
-                                                              lambda-meta
-                                                              lambda?
-                                                              make-dynlet
-                                                              make-letrec
-                                                              make-let
-                                                              make-lambda-case
-                                                              make-lambda
-                                                              make-sequence
-                                                              make-application
-                                                              make-conditional
-                                                              
make-toplevel-define
-                                                              make-toplevel-set
-                                                              make-toplevel-ref
-                                                              make-module-set
-                                                              make-module-ref
-                                                              make-lexical-set
-                                                              make-lexical-ref
-                                                              
make-primitive-ref
-                                                              make-const
-                                                              make-void)
-                                                            ((top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top)
-                                                             (top))
-                                                            ("l-*-476"
-                                                             "l-*-474"
-                                                             "l-*-472"
-                                                             "l-*-470"
-                                                             "l-*-468"
-                                                             "l-*-466"
-                                                             "l-*-464"
-                                                             "l-*-462"
-                                                             "l-*-460"
-                                                             "l-*-458"
-                                                             "l-*-456"
-                                                             "l-*-454"
-                                                             "l-*-452"
-                                                             "l-*-450"
-                                                             "l-*-448"
-                                                             "l-*-446"
-                                                             "l-*-444"
-                                                             "l-*-442"
-                                                             "l-*-440"
-                                                             "l-*-438"
-                                                             "l-*-436"
-                                                             "l-*-434"
-                                                             "l-*-432"
-                                                             "l-*-430"
-                                                             "l-*-428"
-                                                             "l-*-426"
-                                                             "l-*-424"
-                                                             "l-*-422"
-                                                             "l-*-420"
-                                                             "l-*-418"
-                                                             "l-*-416"
-                                                             "l-*-414"
-                                                             "l-*-412"
-                                                             "l-*-410"
-                                                             "l-*-408"
-                                                             "l-*-406"
-                                                             "l-*-404"
-                                                             "l-*-402"
-                                                             "l-*-400"
-                                                             "l-*-399"
-                                                             "l-*-397"
-                                                             "l-*-394"
-                                                             "l-*-393"
-                                                             "l-*-392"
-                                                             "l-*-390"
-                                                             "l-*-389"
-                                                             "l-*-387"
-                                                             "l-*-385"
-                                                             "l-*-383"
-                                                             "l-*-381"
-                                                             "l-*-379"
-                                                             "l-*-377"
-                                                             "l-*-375"
-                                                             "l-*-373"
-                                                             "l-*-370"
-                                                             "l-*-368"
-                                                             "l-*-367"
-                                                             "l-*-365"
-                                                             "l-*-363"
-                                                             "l-*-361"
-                                                             "l-*-359"
-                                                             "l-*-358"
-                                                             "l-*-357"
-                                                             "l-*-356"
-                                                             "l-*-354"
-                                                             "l-*-353"
-                                                             "l-*-350"
-                                                             "l-*-348"
-                                                             "l-*-346"
-                                                             "l-*-344"
-                                                             "l-*-342"
-                                                             "l-*-340"
-                                                             "l-*-338"
-                                                             "l-*-337"
-                                                             "l-*-336"
-                                                             "l-*-334"
-                                                             "l-*-332"
-                                                             "l-*-331"
-                                                             "l-*-328"
-                                                             "l-*-327"
-                                                             "l-*-325"
-                                                             "l-*-323"
-                                                             "l-*-321"
-                                                             "l-*-319"
-                                                             "l-*-317"
-                                                             "l-*-315"
-                                                             "l-*-313"
-                                                             "l-*-311"
-                                                             "l-*-309"
-                                                             "l-*-306"
-                                                             "l-*-304"
-                                                             "l-*-302"
-                                                             "l-*-300"
-                                                             "l-*-298"
-                                                             "l-*-296"
-                                                             "l-*-294"
-                                                             "l-*-292"
-                                                             "l-*-290"
-                                                             "l-*-288"
-                                                             "l-*-286"
-                                                             "l-*-284"
-                                                             "l-*-282"
-                                                             "l-*-280"
-                                                             "l-*-278"
-                                                             "l-*-276"
-                                                             "l-*-274"
-                                                             "l-*-272"
-                                                             "l-*-270"
-                                                             "l-*-268"
-                                                             "l-*-266"
-                                                             "l-*-264"
-                                                             "l-*-262"
-                                                             "l-*-260"
-                                                             "l-*-258"
-                                                             "l-*-256"
-                                                             "l-*-255"
-                                                             "l-*-254"
-                                                             "l-*-253"
-                                                             "l-*-252"
-                                                             "l-*-250"
-                                                             "l-*-248"
-                                                             "l-*-246"
-                                                             "l-*-243"
-                                                             "l-*-241"
-                                                             "l-*-239"
-                                                             "l-*-237"
-                                                             "l-*-235"
-                                                             "l-*-233"
-                                                             "l-*-231"
-                                                             "l-*-229"
-                                                             "l-*-227"
-                                                             "l-*-225"
-                                                             "l-*-223"
-                                                             "l-*-221"
-                                                             "l-*-219"
-                                                             "l-*-217"
-                                                             "l-*-215"
-                                                             "l-*-213"
-                                                             "l-*-211"
-                                                             "l-*-209"))
-                                                          #(ribcage
-                                                            (define-structure
-                                                              
define-expansion-accessors
-                                                              
define-expansion-constructors)
-                                                            ((top) (top) (top))
-                                                            ("l-*-47"
-                                                             "l-*-46"
-                                                             "l-*-45")))
-                                                         (hygiene guile))))
-                                             (eq? (id-var-name-4314
-                                                    x-12226
-                                                    '(()))
-                                                  (id-var-name-4314
-                                                    '#(syntax-object
-                                                       ...
-                                                       ((top)
-                                                        #(ribcage () () ())
-                                                        #(ribcage () () ())
-                                                        #(ribcage
-                                                          #(x)
-                                                          #((top))
-                                                          #("l-*-2267"))
-                                                        #(ribcage
-                                                          (lambda-var-list
-                                                            gen-var
-                                                            strip
-                                                            expand-lambda-case
-                                                            lambda*-formals
-                                                            
expand-simple-lambda
-                                                            lambda-formals
-                                                            ellipsis?
-                                                            expand-void
-                                                            
eval-local-transformer
-                                                            expand-local-syntax
-                                                            expand-body
-                                                            expand-macro
-                                                            expand-application
-                                                            expand-expr
-                                                            expand
-                                                            syntax-type
-                                                            parse-when-list
-                                                            
expand-install-global
-                                                            expand-top-sequence
-                                                            expand-sequence
-                                                            source-wrap
-                                                            wrap
-                                                            bound-id-member?
-                                                            distinct-bound-ids?
-                                                            valid-bound-ids?
-                                                            bound-id=?
-                                                            free-id=?
-                                                            
with-transformer-environment
-                                                            
transformer-environment
-                                                            resolve-identifier
-                                                            
locally-bound-identifiers
-                                                            id-var-name
-                                                            same-marks?
-                                                            join-marks
-                                                            join-wraps
-                                                            smart-append
-                                                            make-binding-wrap
-                                                            extend-ribcage!
-                                                            make-empty-ribcage
-                                                            new-mark
-                                                            anti-mark
-                                                            the-anti-mark
-                                                            top-marked?
-                                                            top-wrap
-                                                            empty-wrap
-                                                            set-ribcage-labels!
-                                                            set-ribcage-marks!
-                                                            
set-ribcage-symnames!
-                                                            ribcage-labels
-                                                            ribcage-marks
-                                                            ribcage-symnames
-                                                            ribcage?
-                                                            make-ribcage
-                                                            gen-labels
-                                                            gen-label
-                                                            make-rename
-                                                            rename-marks
-                                                            rename-new
-                                                            rename-old
-                                                            subst-rename?
-                                                            wrap-subst
-                                                            wrap-marks
-                                                            make-wrap
-                                                            id-sym-name&marks
-                                                            id-sym-name
-                                                            id?
-                                                            nonsymbol-id?
-                                                            global-extend
-                                                            lookup
-                                                            macros-only-env
-                                                            extend-var-env
-                                                            extend-env
-                                                            null-env
-                                                            binding-value
-                                                            binding-type
-                                                            make-binding
-                                                            arg-check
-                                                            source-annotation
-                                                            no-source
-                                                            
set-syntax-object-module!
-                                                            
set-syntax-object-wrap!
-                                                            
set-syntax-object-expression!
-                                                            
syntax-object-module
-                                                            syntax-object-wrap
-                                                            
syntax-object-expression
-                                                            syntax-object?
-                                                            make-syntax-object
-                                                            build-lexical-var
-                                                            build-letrec
-                                                            build-named-let
-                                                            build-let
-                                                            build-sequence
-                                                            build-data
-                                                            build-primref
-                                                            build-lambda-case
-                                                            build-case-lambda
-                                                            build-simple-lambda
-                                                            
build-global-definition
-                                                            
build-global-assignment
-                                                            
build-global-reference
-                                                            analyze-variable
-                                                            
build-lexical-assignment
-                                                            
build-lexical-reference
-                                                            build-dynlet
-                                                            build-conditional
-                                                            build-application
-                                                            build-void
-                                                            maybe-name-value!
-                                                            decorate-source
-                                                            
get-global-definition-hook
-                                                            
put-global-definition-hook
-                                                            session-id
-                                                            local-eval-hook
-                                                            top-level-eval-hook
-                                                            fx<
-                                                            fx=
-                                                            fx-
-                                                            fx+
-                                                            set-lambda-meta!
-                                                            lambda-meta
-                                                            lambda?
-                                                            make-dynlet
-                                                            make-letrec
-                                                            make-let
-                                                            make-lambda-case
-                                                            make-lambda
-                                                            make-sequence
-                                                            make-application
-                                                            make-conditional
-                                                            
make-toplevel-define
-                                                            make-toplevel-set
-                                                            make-toplevel-ref
-                                                            make-module-set
-                                                            make-module-ref
-                                                            make-lexical-set
-                                                            make-lexical-ref
-                                                            make-primitive-ref
-                                                            make-const
-                                                            make-void)
-                                                          ((top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top))
-                                                          ("l-*-476"
-                                                           "l-*-474"
-                                                           "l-*-472"
-                                                           "l-*-470"
-                                                           "l-*-468"
-                                                           "l-*-466"
-                                                           "l-*-464"
-                                                           "l-*-462"
-                                                           "l-*-460"
-                                                           "l-*-458"
-                                                           "l-*-456"
-                                                           "l-*-454"
-                                                           "l-*-452"
-                                                           "l-*-450"
-                                                           "l-*-448"
-                                                           "l-*-446"
-                                                           "l-*-444"
-                                                           "l-*-442"
-                                                           "l-*-440"
-                                                           "l-*-438"
-                                                           "l-*-436"
-                                                           "l-*-434"
-                                                           "l-*-432"
-                                                           "l-*-430"
-                                                           "l-*-428"
-                                                           "l-*-426"
-                                                           "l-*-424"
-                                                           "l-*-422"
-                                                           "l-*-420"
-                                                           "l-*-418"
-                                                           "l-*-416"
-                                                           "l-*-414"
-                                                           "l-*-412"
-                                                           "l-*-410"
-                                                           "l-*-408"
-                                                           "l-*-406"
-                                                           "l-*-404"
-                                                           "l-*-402"
-                                                           "l-*-400"
-                                                           "l-*-399"
-                                                           "l-*-397"
-                                                           "l-*-394"
-                                                           "l-*-393"
-                                                           "l-*-392"
-                                                           "l-*-390"
-                                                           "l-*-389"
-                                                           "l-*-387"
-                                                           "l-*-385"
-