guile-commits
[Top][All Lists]
Advanced

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

[Guile-commits] GNU Guile branch, master, updated. v2.1.0-30-g2988685


From: Andy Wingo
Subject: [Guile-commits] GNU Guile branch, master, updated. v2.1.0-30-g2988685
Date: Wed, 15 Feb 2012 22:05:04 +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=2988685d847a46ab1b3adeb4edfe17982a0643fc

The branch, master has been updated
       via  2988685d847a46ab1b3adeb4edfe17982a0643fc (commit)
       via  bbd1281ae5551e31d1bc720c7e93528619e0a693 (commit)
       via  30398e94f9cadfaff44117bbff214b0b7ba703ca (commit)
       via  db2430688723676a3c7025d04aa1abd73c6b328e (commit)
       via  eec3a50867086782a01286b742ee43f9fd47ecba (commit)
      from  df655031011719067e2b6819572a262028bb4858 (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 2988685d847a46ab1b3adeb4edfe17982a0643fc
Merge: df65503 bbd1281
Author: Andy Wingo <address@hidden>
Date:   Wed Feb 15 23:04:53 2012 +0100

    Merge remote-tracking branch 'origin/stable-2.0'
    
    Conflicts:
        module/ice-9/psyntax-pp.scm

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

Summary of changes:
 module/ice-9/psyntax-pp.scm    |17382 ++++++++++++++++++++--------------------
 module/ice-9/psyntax.scm       |   13 +-
 module/system/base/message.scm |    2 +-
 module/web/server.scm          |    4 +-
 4 files changed, 8712 insertions(+), 8689 deletions(-)

diff --git a/module/ice-9/psyntax-pp.scm b/module/ice-9/psyntax-pp.scm
index 847a25b..0e353d8 100644
--- a/module/ice-9/psyntax-pp.scm
+++ b/module/ice-9/psyntax-pp.scm
@@ -1,2176 +1,2176 @@
 (eval-when (compile) (set-current-module (resolve-module (quote (guile)))))
 (if #f #f)
 
-(let ((session-id-4511 (if #f #f))
-      (transformer-environment-4572 (if #f #f)))
+(let ((session-id-4307 (if #f #f))
+      (transformer-environment-4368 (if #f #f)))
   (letrec*
-    ((top-level-eval-hook-4509
-       (lambda (x-36254 mod-36255)
-         (primitive-eval x-36254)))
-     (maybe-name-value!-4515
-       (lambda (name-19069 val-19070)
-         (if (if (struct? val-19070)
-               (eq? (struct-vtable val-19070)
+    ((top-level-eval-hook-4305
+       (lambda (x-36477 mod-36478)
+         (primitive-eval x-36477)))
+     (maybe-name-value!-4311
+       (lambda (name-19172 val-19173)
+         (if (if (struct? val-19173)
+               (eq? (struct-vtable val-19173)
                     (vector-ref %expanded-vtables 14))
                #f)
-           (let ((meta-19077 (struct-ref val-19070 1)))
-             (if (not (assq 'name meta-19077))
-               (let ((v-19082
-                       (cons (cons 'name name-19069) meta-19077)))
-                 (struct-set! val-19070 1 v-19082)))))))
-     (build-call-4517
-       (lambda (source-18814 fun-exp-18815 arg-exps-18816)
+           (let ((meta-19180 (struct-ref val-19173 1)))
+             (if (not (assq 'name meta-19180))
+               (let ((v-19185
+                       (cons (cons 'name name-19172) meta-19180)))
+                 (struct-set! val-19173 1 v-19185)))))))
+     (build-call-4313
+       (lambda (source-18917 fun-exp-18918 arg-exps-18919)
          (make-struct/no-tail
            (vector-ref %expanded-vtables 11)
-           source-18814
-           fun-exp-18815
-           arg-exps-18816)))
-     (build-conditional-4518
-       (lambda (source-18822
-                test-exp-18823
-                then-exp-18824
-                else-exp-18825)
+           source-18917
+           fun-exp-18918
+           arg-exps-18919)))
+     (build-conditional-4314
+       (lambda (source-18925
+                test-exp-18926
+                then-exp-18927
+                else-exp-18928)
          (make-struct/no-tail
            (vector-ref %expanded-vtables 10)
-           source-18822
-           test-exp-18823
-           then-exp-18824
-           else-exp-18825)))
-     (build-dynlet-4519
-       (lambda (source-18832 fluids-18833 vals-18834 body-18835)
+           source-18925
+           test-exp-18926
+           then-exp-18927
+           else-exp-18928)))
+     (build-dynlet-4315
+       (lambda (source-18935 fluids-18936 vals-18937 body-18938)
          (make-struct/no-tail
            (vector-ref %expanded-vtables 18)
-           source-18832
-           fluids-18833
-           vals-18834
-           body-18835)))
-     (build-lexical-reference-4520
-       (lambda (type-36256 source-36257 name-36258 var-36259)
+           source-18935
+           fluids-18936
+           vals-18937
+           body-18938)))
+     (build-lexical-reference-4316
+       (lambda (type-36479 source-36480 name-36481 var-36482)
          (make-struct/no-tail
            (vector-ref %expanded-vtables 3)
-           source-36257
-           name-36258
-           var-36259)))
-     (build-lexical-assignment-4521
-       (lambda (source-18842 name-18843 var-18844 exp-18845)
+           source-36480
+           name-36481
+           var-36482)))
+     (build-lexical-assignment-4317
+       (lambda (source-18945 name-18946 var-18947 exp-18948)
          (begin
-           (if (if (struct? exp-18845)
-                 (eq? (struct-vtable exp-18845)
+           (if (if (struct? exp-18948)
+                 (eq? (struct-vtable exp-18948)
                       (vector-ref %expanded-vtables 14))
                  #f)
-             (let ((meta-18861 (struct-ref exp-18845 1)))
-               (if (not (assq 'name meta-18861))
-                 (let ((v-18868
-                         (cons (cons 'name name-18843) meta-18861)))
-                   (struct-set! exp-18845 1 v-18868)))))
+             (let ((meta-18964 (struct-ref exp-18948 1)))
+               (if (not (assq 'name meta-18964))
+                 (let ((v-18971
+                         (cons (cons 'name name-18946) meta-18964)))
+                   (struct-set! exp-18948 1 v-18971)))))
            (make-struct/no-tail
              (vector-ref %expanded-vtables 4)
-             source-18842
-             name-18843
-             var-18844
-             exp-18845))))
-     (analyze-variable-4522
-       (lambda (mod-36265
-                var-36266
-                modref-cont-36267
-                bare-cont-36268)
-         (if (not mod-36265)
-           (bare-cont-36268 var-36266)
-           (let ((kind-36269 (car mod-36265))
-                 (mod-36270 (cdr mod-36265)))
-             (if (eqv? kind-36269 'public)
-               (modref-cont-36267 mod-36270 var-36266 #t)
-               (if (eqv? kind-36269 'private)
-                 (if (not (equal? mod-36270 (module-name (current-module))))
-                   (modref-cont-36267 mod-36270 var-36266 #f)
-                   (bare-cont-36268 var-36266))
-                 (if (eqv? kind-36269 'bare)
-                   (bare-cont-36268 var-36266)
-                   (if (eqv? kind-36269 'hygiene)
+             source-18945
+             name-18946
+             var-18947
+             exp-18948))))
+     (analyze-variable-4318
+       (lambda (mod-36488
+                var-36489
+                modref-cont-36490
+                bare-cont-36491)
+         (if (not mod-36488)
+           (bare-cont-36491 var-36489)
+           (let ((kind-36492 (car mod-36488))
+                 (mod-36493 (cdr mod-36488)))
+             (if (eqv? kind-36492 'public)
+               (modref-cont-36490 mod-36493 var-36489 #t)
+               (if (eqv? kind-36492 'private)
+                 (if (not (equal? mod-36493 (module-name (current-module))))
+                   (modref-cont-36490 mod-36493 var-36489 #f)
+                   (bare-cont-36491 var-36489))
+                 (if (eqv? kind-36492 'bare)
+                   (bare-cont-36491 var-36489)
+                   (if (eqv? kind-36492 'hygiene)
                      (if (if (not (equal?
-                                    mod-36270
+                                    mod-36493
                                     (module-name (current-module))))
                            (module-variable
-                             (resolve-module mod-36270)
-                             var-36266)
+                             (resolve-module mod-36493)
+                             var-36489)
                            #f)
-                       (modref-cont-36267 mod-36270 var-36266 #f)
-                       (bare-cont-36268 var-36266))
+                       (modref-cont-36490 mod-36493 var-36489 #f)
+                       (bare-cont-36491 var-36489))
                      (syntax-violation
                        #f
                        "bad module kind"
-                       var-36266
-                       mod-36270)))))))))
-     (build-global-reference-4523
-       (lambda (source-36285 var-36286 mod-36287)
-         (analyze-variable-4522
-           mod-36287
-           var-36286
-           (lambda (mod-36290 var-36291 public?-36292)
+                       var-36489
+                       mod-36493)))))))))
+     (build-global-reference-4319
+       (lambda (source-36520 var-36521 mod-36522)
+         (analyze-variable-4318
+           mod-36522
+           var-36521
+           (lambda (mod-36525 var-36526 public?-36527)
              (make-struct/no-tail
                (vector-ref %expanded-vtables 5)
-               source-36285
-               mod-36290
-               var-36291
-               public?-36292))
-           (lambda (var-36299)
+               source-36520
+               mod-36525
+               var-36526
+               public?-36527))
+           (lambda (var-36534)
              (make-struct/no-tail
                (vector-ref %expanded-vtables 7)
-               source-36285
-               var-36299)))))
-     (build-global-assignment-4524
-       (lambda (source-18877 var-18878 exp-18879 mod-18880)
+               source-36520
+               var-36534)))))
+     (build-global-assignment-4320
+       (lambda (source-18980 var-18981 exp-18982 mod-18983)
          (begin
-           (if (if (struct? exp-18879)
-                 (eq? (struct-vtable exp-18879)
+           (if (if (struct? exp-18982)
+                 (eq? (struct-vtable exp-18982)
                       (vector-ref %expanded-vtables 14))
                  #f)
-             (let ((meta-18896 (struct-ref exp-18879 1)))
-               (if (not (assq 'name meta-18896))
-                 (let ((v-18903
-                         (cons (cons 'name var-18878) meta-18896)))
-                   (struct-set! exp-18879 1 v-18903)))))
-           (analyze-variable-4522
-             mod-18880
-             var-18878
-             (lambda (mod-18908 var-18909 public?-18910)
+             (let ((meta-18999 (struct-ref exp-18982 1)))
+               (if (not (assq 'name meta-18999))
+                 (let ((v-19006
+                         (cons (cons 'name var-18981) meta-18999)))
+                   (struct-set! exp-18982 1 v-19006)))))
+           (analyze-variable-4318
+             mod-18983
+             var-18981
+             (lambda (mod-19011 var-19012 public?-19013)
                (make-struct/no-tail
                  (vector-ref %expanded-vtables 6)
-                 source-18877
-                 mod-18908
-                 var-18909
-                 public?-18910
-                 exp-18879))
-             (lambda (var-18918)
+                 source-18980
+                 mod-19011
+                 var-19012
+                 public?-19013
+                 exp-18982))
+             (lambda (var-19021)
                (make-struct/no-tail
                  (vector-ref %expanded-vtables 8)
-                 source-18877
-                 var-18918
-                 exp-18879))))))
-     (build-global-definition-4525
-       (lambda (source-36304 var-36305 exp-36306)
+                 source-18980
+                 var-19021
+                 exp-18982))))))
+     (build-global-definition-4321
+       (lambda (source-36539 var-36540 exp-36541)
          (begin
-           (if (if (struct? exp-36306)
-                 (eq? (struct-vtable exp-36306)
+           (if (if (struct? exp-36541)
+                 (eq? (struct-vtable exp-36541)
                       (vector-ref %expanded-vtables 14))
                  #f)
-             (let ((meta-36322 (struct-ref exp-36306 1)))
-               (if (not (assq 'name meta-36322))
-                 (let ((v-36329
-                         (cons (cons 'name var-36305) meta-36322)))
-                   (struct-set! exp-36306 1 v-36329)))))
+             (let ((meta-36557 (struct-ref exp-36541 1)))
+               (if (not (assq 'name meta-36557))
+                 (let ((v-36564
+                         (cons (cons 'name var-36540) meta-36557)))
+                   (struct-set! exp-36541 1 v-36564)))))
            (make-struct/no-tail
              (vector-ref %expanded-vtables 9)
-             source-36304
-             var-36305
-             exp-36306))))
-     (build-simple-lambda-4526
-       (lambda (src-18924
-                req-18925
-                rest-18926
-                vars-18927
-                meta-18928
-                exp-18929)
-         (let ((body-18935
+             source-36539
+             var-36540
+             exp-36541))))
+     (build-simple-lambda-4322
+       (lambda (src-19027
+                req-19028
+                rest-19029
+                vars-19030
+                meta-19031
+                exp-19032)
+         (let ((body-19038
                  (make-struct/no-tail
                    (vector-ref %expanded-vtables 15)
-                   src-18924
-                   req-18925
+                   src-19027
+                   req-19028
                    #f
-                   rest-18926
+                   rest-19029
                    #f
                    '()
-                   vars-18927
-                   exp-18929
+                   vars-19030
+                   exp-19032
                    #f)))
            (make-struct/no-tail
              (vector-ref %expanded-vtables 14)
-             src-18924
-             meta-18928
-             body-18935))))
-     (build-primcall-4529
-       (lambda (src-18947 name-18948 args-18949)
+             src-19027
+             meta-19031
+             body-19038))))
+     (build-primcall-4325
+       (lambda (src-19050 name-19051 args-19052)
          (make-struct/no-tail
            (vector-ref %expanded-vtables 12)
-           src-18947
-           name-18948
-           args-18949)))
-     (build-sequence-4532
-       (lambda (src-36337 exps-36338)
-         (if (null? (cdr exps-36338))
-           (car exps-36338)
-           (let ((head-36342 (car exps-36338))
-                 (tail-36343
-                   (build-sequence-4532 #f (cdr exps-36338))))
+           src-19050
+           name-19051
+           args-19052)))
+     (build-sequence-4328
+       (lambda (src-36572 exps-36573)
+         (if (null? (cdr exps-36573))
+           (car exps-36573)
+           (let ((head-36577 (car exps-36573))
+                 (tail-36578
+                   (build-sequence-4328 #f (cdr exps-36573))))
              (make-struct/no-tail
                (vector-ref %expanded-vtables 13)
-               src-36337
-               head-36342
-               tail-36343)))))
-     (build-named-let-4534
-       (lambda (src-18955
-                ids-18956
-                vars-18957
-                val-exps-18958
-                body-exp-18959)
-         (let ((f-18960 (car vars-18957))
-               (f-name-18961 (car ids-18956))
-               (vars-18962 (cdr vars-18957))
-               (ids-18963 (cdr ids-18956)))
-           (let ((proc-18964
-                   (let ((body-18984
+               src-36572
+               head-36577
+               tail-36578)))))
+     (build-named-let-4330
+       (lambda (src-19058
+                ids-19059
+                vars-19060
+                val-exps-19061
+                body-exp-19062)
+         (let ((f-19063 (car vars-19060))
+               (f-name-19064 (car ids-19059))
+               (vars-19065 (cdr vars-19060))
+               (ids-19066 (cdr ids-19059)))
+           (let ((proc-19067
+                   (let ((body-19087
                            (make-struct/no-tail
                              (vector-ref %expanded-vtables 15)
-                             src-18955
-                             ids-18963
+                             src-19058
+                             ids-19066
                              #f
                              #f
                              #f
                              '()
-                             vars-18962
-                             body-exp-18959
+                             vars-19065
+                             body-exp-19062
                              #f)))
                      (make-struct/no-tail
                        (vector-ref %expanded-vtables 14)
-                       src-18955
+                       src-19058
                        '()
-                       body-18984))))
+                       body-19087))))
              (begin
-               (if (if (struct? proc-18964)
-                     (eq? (struct-vtable proc-18964)
+               (if (if (struct? proc-19067)
+                     (eq? (struct-vtable proc-19067)
                           (vector-ref %expanded-vtables 14))
                      #f)
-                 (let ((meta-19008 (struct-ref proc-18964 1)))
-                   (if (not (assq 'name meta-19008))
-                     (let ((v-19015
-                             (cons (cons 'name f-name-18961) meta-19008)))
-                       (struct-set! proc-18964 1 v-19015)))))
+                 (let ((meta-19111 (struct-ref proc-19067 1)))
+                   (if (not (assq 'name meta-19111))
+                     (let ((v-19118
+                             (cons (cons 'name f-name-19064) meta-19111)))
+                       (struct-set! proc-19067 1 v-19118)))))
                (for-each
-                 maybe-name-value!-4515
-                 ids-18963
-                 val-exps-18958)
-               (let ((names-19039 (list f-name-18961))
-                     (gensyms-19040 (list f-18960))
-                     (vals-19041 (list proc-18964))
-                     (body-19042
-                       (let ((fun-exp-19046
+                 maybe-name-value!-4311
+                 ids-19066
+                 val-exps-19061)
+               (let ((names-19142 (list f-name-19064))
+                     (gensyms-19143 (list f-19063))
+                     (vals-19144 (list proc-19067))
+                     (body-19145
+                       (let ((fun-exp-19149
                                (make-struct/no-tail
                                  (vector-ref %expanded-vtables 3)
-                                 src-18955
-                                 f-name-18961
-                                 f-18960)))
+                                 src-19058
+                                 f-name-19064
+                                 f-19063)))
                          (make-struct/no-tail
                            (vector-ref %expanded-vtables 11)
-                           src-18955
-                           fun-exp-19046
-                           val-exps-18958))))
+                           src-19058
+                           fun-exp-19149
+                           val-exps-19061))))
                  (make-struct/no-tail
                    (vector-ref %expanded-vtables 17)
-                   src-18955
+                   src-19058
                    #f
-                   names-19039
-                   gensyms-19040
-                   vals-19041
-                   body-19042)))))))
-     (build-letrec-4535
-       (lambda (src-19062
-                in-order?-19063
-                ids-19064
-                vars-19065
-                val-exps-19066
-                body-exp-19067)
-         (if (null? vars-19065)
-           body-exp-19067
+                   names-19142
+                   gensyms-19143
+                   vals-19144
+                   body-19145)))))))
+     (build-letrec-4331
+       (lambda (src-19165
+                in-order?-19166
+                ids-19167
+                vars-19168
+                val-exps-19169
+                body-exp-19170)
+         (if (null? vars-19168)
+           body-exp-19170
            (begin
              (for-each
-               maybe-name-value!-4515
-               ids-19064
-               val-exps-19066)
+               maybe-name-value!-4311
+               ids-19167
+               val-exps-19169)
              (make-struct/no-tail
                (vector-ref %expanded-vtables 17)
-               src-19062
-               in-order?-19063
-               ids-19064
-               vars-19065
-               val-exps-19066
-               body-exp-19067)))))
-     (source-annotation-4544
-       (lambda (x-19093)
-         (if (if (vector? x-19093)
-               (if (= (vector-length x-19093) 4)
-                 (eq? (vector-ref x-19093 0) 'syntax-object)
+               src-19165
+               in-order?-19166
+               ids-19167
+               vars-19168
+               val-exps-19169
+               body-exp-19170)))))
+     (source-annotation-4340
+       (lambda (x-19196)
+         (if (if (vector? x-19196)
+               (if (= (vector-length x-19196) 4)
+                 (eq? (vector-ref x-19196 0) 'syntax-object)
                  #f)
                #f)
-           (source-annotation-4544 (vector-ref x-19093 1))
-           (if (pair? x-19093)
-             (let ((props-19108 (source-properties x-19093)))
-               (if (pair? props-19108) props-19108 #f))
+           (source-annotation-4340 (vector-ref x-19196 1))
+           (if (pair? x-19196)
+             (let ((props-19211 (source-properties x-19196)))
+               (if (pair? props-19211) props-19211 #f))
              #f))))
-     (extend-env-4545
-       (lambda (labels-19110 bindings-19111 r-19112)
-         (if (null? labels-19110)
-           r-19112
-           (extend-env-4545
-             (cdr labels-19110)
-             (cdr bindings-19111)
-             (cons (cons (car labels-19110) (car bindings-19111))
-                   r-19112)))))
-     (extend-var-env-4546
-       (lambda (labels-19113 vars-19114 r-19115)
-         (if (null? labels-19113)
-           r-19115
-           (extend-var-env-4546
-             (cdr labels-19113)
-             (cdr vars-19114)
-             (cons (cons (car labels-19113)
-                         (cons 'lexical (car vars-19114)))
-                   r-19115)))))
-     (macros-only-env-4547
-       (lambda (r-19116)
-         (if (null? r-19116)
+     (extend-env-4341
+       (lambda (labels-19213 bindings-19214 r-19215)
+         (if (null? labels-19213)
+           r-19215
+           (extend-env-4341
+             (cdr labels-19213)
+             (cdr bindings-19214)
+             (cons (cons (car labels-19213) (car bindings-19214))
+                   r-19215)))))
+     (extend-var-env-4342
+       (lambda (labels-19216 vars-19217 r-19218)
+         (if (null? labels-19216)
+           r-19218
+           (extend-var-env-4342
+             (cdr labels-19216)
+             (cdr vars-19217)
+             (cons (cons (car labels-19216)
+                         (cons 'lexical (car vars-19217)))
+                   r-19218)))))
+     (macros-only-env-4343
+       (lambda (r-19219)
+         (if (null? r-19219)
            '()
-           (let ((a-19117 (car r-19116)))
-             (if (let ((t-19120 (car (cdr a-19117))))
-                   (if (eq? t-19120 'macro)
+           (let ((a-19220 (car r-19219)))
+             (if (let ((t-19223 (car (cdr a-19220))))
+                   (if (eq? t-19223 'macro)
                      #t
-                     (eq? t-19120 'syntax-parameter)))
-               (cons a-19117
-                     (macros-only-env-4547 (cdr r-19116)))
-               (macros-only-env-4547 (cdr r-19116)))))))
-     (global-extend-4548
-       (lambda (type-19122 sym-19123 val-19124)
+                     (eq? t-19223 'syntax-parameter)))
+               (cons a-19220
+                     (macros-only-env-4343 (cdr r-19219)))
+               (macros-only-env-4343 (cdr r-19219)))))))
+     (global-extend-4344
+       (lambda (type-19225 sym-19226 val-19227)
          (module-define!
            (current-module)
-           sym-19123
+           sym-19226
            (make-syntax-transformer
-             sym-19123
-             type-19122
-             val-19124))))
-     (id?-4550
-       (lambda (x-11889)
-         (if (symbol? x-11889)
+             sym-19226
+             type-19225
+             val-19227))))
+     (id?-4346
+       (lambda (x-11718)
+         (if (symbol? x-11718)
            #t
-           (if (if (vector? x-11889)
-                 (if (= (vector-length x-11889) 4)
-                   (eq? (vector-ref x-11889 0) 'syntax-object)
+           (if (if (vector? x-11718)
+                 (if (= (vector-length x-11718) 4)
+                   (eq? (vector-ref x-11718 0) 'syntax-object)
                    #f)
                  #f)
-             (symbol? (vector-ref x-11889 1))
+             (symbol? (vector-ref x-11718 1))
              #f))))
-     (gen-labels-4553
-       (lambda (ls-19134)
-         (if (null? ls-19134)
+     (gen-labels-4349
+       (lambda (ls-19237)
+         (if (null? ls-19237)
            '()
            (cons (string-append
                    "l-"
-                   (session-id-4511)
+                   (session-id-4307)
                    (symbol->string (gensym "-")))
-                 (gen-labels-4553 (cdr ls-19134))))))
-     (make-binding-wrap-4564
-       (lambda (ids-19138 labels-19139 w-19140)
-         (if (null? ids-19138)
-           w-19140
-           (cons (car w-19140)
-                 (cons (let ((labelvec-19141 (list->vector labels-19139)))
-                         (let ((n-19142 (vector-length labelvec-19141)))
-                           (let ((symnamevec-19143 (make-vector n-19142))
-                                 (marksvec-19144 (make-vector n-19142)))
+                 (gen-labels-4349 (cdr ls-19237))))))
+     (make-binding-wrap-4360
+       (lambda (ids-19241 labels-19242 w-19243)
+         (if (null? ids-19241)
+           w-19243
+           (cons (car w-19243)
+                 (cons (let ((labelvec-19244 (list->vector labels-19242)))
+                         (let ((n-19245 (vector-length labelvec-19244)))
+                           (let ((symnamevec-19246 (make-vector n-19245))
+                                 (marksvec-19247 (make-vector n-19245)))
                              (begin
                                (letrec*
-                                 ((f-19145
-                                    (lambda (ids-19342 i-19343)
-                                      (if (not (null? ids-19342))
+                                 ((f-19248
+                                    (lambda (ids-19445 i-19446)
+                                      (if (not (null? ids-19445))
                                         (call-with-values
                                           (lambda ()
-                                            (let ((x-19346 (car ids-19342)))
-                                              (if (if (vector? x-19346)
+                                            (let ((x-19449 (car ids-19445)))
+                                              (if (if (vector? x-19449)
                                                     (if (= (vector-length
-                                                             x-19346)
+                                                             x-19449)
                                                            4)
                                                       (eq? (vector-ref
-                                                             x-19346
+                                                             x-19449
                                                              0)
                                                            'syntax-object)
                                                       #f)
                                                     #f)
                                                 (values
-                                                  (vector-ref x-19346 1)
-                                                  (let ((m1-19362
-                                                          (car w-19140))
-                                                        (m2-19363
+                                                  (vector-ref x-19449 1)
+                                                  (let ((m1-19465
+                                                          (car w-19243))
+                                                        (m2-19466
                                                           (car (vector-ref
-                                                                 x-19346
+                                                                 x-19449
                                                                  2))))
-                                                    (if (null? m2-19363)
-                                                      m1-19362
+                                                    (if (null? m2-19466)
+                                                      m1-19465
                                                       (append
-                                                        m1-19362
-                                                        m2-19363))))
+                                                        m1-19465
+                                                        m2-19466))))
                                                 (values
-                                                  x-19346
-                                                  (car w-19140)))))
-                                          (lambda (symname-19383 marks-19384)
+                                                  x-19449
+                                                  (car w-19243)))))
+                                          (lambda (symname-19486 marks-19487)
                                             (begin
                                               (vector-set!
-                                                symnamevec-19143
-                                                i-19343
-                                                symname-19383)
+                                                symnamevec-19246
+                                                i-19446
+                                                symname-19486)
                                               (vector-set!
-                                                marksvec-19144
-                                                i-19343
-                                                marks-19384)
-                                              (f-19145
-                                                (cdr ids-19342)
-                                                (#{1+}# i-19343)))))))))
-                                 (f-19145 ids-19138 0))
+                                                marksvec-19247
+                                                i-19446
+                                                marks-19487)
+                                              (f-19248
+                                                (cdr ids-19445)
+                                                (#{1+}# i-19446)))))))))
+                                 (f-19248 ids-19241 0))
                                (vector
                                  'ribcage
-                                 symnamevec-19143
-                                 marksvec-19144
-                                 labelvec-19141)))))
-                       (cdr w-19140))))))
-     (same-marks?-4568
-       (lambda (x-36344 y-36345)
-         (if (eq? x-36344 y-36345)
-           (eq? x-36344 y-36345)
-           (if (not (null? x-36344))
-             (if (not (null? y-36345))
-               (if (eq? (car x-36344) (car y-36345))
-                 (same-marks?-4568 (cdr x-36344) (cdr y-36345))
+                                 symnamevec-19246
+                                 marksvec-19247
+                                 labelvec-19244)))))
+                       (cdr w-19243))))))
+     (same-marks?-4364
+       (lambda (x-36579 y-36580)
+         (if (eq? x-36579 y-36580)
+           (eq? x-36579 y-36580)
+           (if (not (null? x-36579))
+             (if (not (null? y-36580))
+               (if (eq? (car x-36579) (car y-36580))
+                 (same-marks?-4364 (cdr x-36579) (cdr y-36580))
                  #f)
                #f)
              #f))))
-     (id-var-name-4569
-       (lambda (id-36353 w-36354 mod-36355)
+     (id-var-name-4365
+       (lambda (id-36588 w-36589 mod-36590)
          (letrec*
-           ((search-36356
-              (lambda (sym-36422 subst-36423 marks-36424 mod-36425)
-                (if (null? subst-36423)
-                  (values #f marks-36424)
-                  (let ((fst-36426 (car subst-36423)))
-                    (if (eq? fst-36426 'shift)
-                      (search-36356
-                        sym-36422
-                        (cdr subst-36423)
-                        (cdr marks-36424)
-                        mod-36425)
-                      (let ((symnames-36428 (vector-ref fst-36426 1)))
-                        (if (vector? symnames-36428)
-                          (search-vector-rib-36358
-                            sym-36422
-                            subst-36423
-                            marks-36424
-                            symnames-36428
-                            fst-36426
-                            mod-36425)
-                          (search-list-rib-36357
-                            sym-36422
-                            subst-36423
-                            marks-36424
-                            symnames-36428
-                            fst-36426
-                            mod-36425))))))))
-            (search-list-rib-36357
-              (lambda (sym-36603
-                       subst-36604
-                       marks-36605
-                       symnames-36606
-                       ribcage-36607
-                       mod-36608)
+           ((search-36591
+              (lambda (sym-36657 subst-36658 marks-36659 mod-36660)
+                (if (null? subst-36658)
+                  (values #f marks-36659)
+                  (let ((fst-36661 (car subst-36658)))
+                    (if (eq? fst-36661 'shift)
+                      (search-36591
+                        sym-36657
+                        (cdr subst-36658)
+                        (cdr marks-36659)
+                        mod-36660)
+                      (let ((symnames-36663 (vector-ref fst-36661 1)))
+                        (if (vector? symnames-36663)
+                          (search-vector-rib-36593
+                            sym-36657
+                            subst-36658
+                            marks-36659
+                            symnames-36663
+                            fst-36661
+                            mod-36660)
+                          (search-list-rib-36592
+                            sym-36657
+                            subst-36658
+                            marks-36659
+                            symnames-36663
+                            fst-36661
+                            mod-36660))))))))
+            (search-list-rib-36592
+              (lambda (sym-36838
+                       subst-36839
+                       marks-36840
+                       symnames-36841
+                       ribcage-36842
+                       mod-36843)
                 (letrec*
-                  ((f-36609
-                     (lambda (symnames-36612 i-36613)
-                       (if (null? symnames-36612)
-                         (search-36356
-                           sym-36603
-                           (cdr subst-36604)
-                           marks-36605
-                           mod-36608)
-                         (if (if (eq? (car symnames-36612) sym-36603)
-                               (same-marks?-4568
-                                 marks-36605
+                  ((f-36844
+                     (lambda (symnames-36847 i-36848)
+                       (if (null? symnames-36847)
+                         (search-36591
+                           sym-36838
+                           (cdr subst-36839)
+                           marks-36840
+                           mod-36843)
+                         (if (if (eq? (car symnames-36847) sym-36838)
+                               (same-marks?-4364
+                                 marks-36840
                                  (list-ref
-                                   (vector-ref ribcage-36607 2)
-                                   i-36613))
+                                   (vector-ref ribcage-36842 2)
+                                   i-36848))
                                #f)
-                           (let ((n-36759
+                           (let ((n-36994
                                    (list-ref
-                                     (vector-ref ribcage-36607 3)
-                                     i-36613)))
-                             (if (pair? n-36759)
-                               (if (equal? mod-36608 (car n-36759))
-                                 (values (cdr n-36759) marks-36605)
-                                 (f-36609
-                                   (cdr symnames-36612)
-                                   (#{1+}# i-36613)))
-                               (values n-36759 marks-36605)))
-                           (f-36609 (cdr symnames-36612) (#{1+}# i-36613)))))))
-                  (f-36609 symnames-36606 0))))
-            (search-vector-rib-36358
-              (lambda (sym-36764
-                       subst-36765
-                       marks-36766
-                       symnames-36767
-                       ribcage-36768
-                       mod-36769)
-                (let ((n-36770 (vector-length symnames-36767)))
+                                     (vector-ref ribcage-36842 3)
+                                     i-36848)))
+                             (if (pair? n-36994)
+                               (if (equal? mod-36843 (car n-36994))
+                                 (values (cdr n-36994) marks-36840)
+                                 (f-36844
+                                   (cdr symnames-36847)
+                                   (#{1+}# i-36848)))
+                               (values n-36994 marks-36840)))
+                           (f-36844 (cdr symnames-36847) (#{1+}# i-36848)))))))
+                  (f-36844 symnames-36841 0))))
+            (search-vector-rib-36593
+              (lambda (sym-36999
+                       subst-37000
+                       marks-37001
+                       symnames-37002
+                       ribcage-37003
+                       mod-37004)
+                (let ((n-37005 (vector-length symnames-37002)))
                   (letrec*
-                    ((f-36771
-                       (lambda (i-36774)
-                         (if (= i-36774 n-36770)
-                           (search-36356
-                             sym-36764
-                             (cdr subst-36765)
-                             marks-36766
-                             mod-36769)
-                           (if (if (eq? (vector-ref symnames-36767 i-36774)
-                                        sym-36764)
-                                 (same-marks?-4568
-                                   marks-36766
+                    ((f-37006
+                       (lambda (i-37009)
+                         (if (= i-37009 n-37005)
+                           (search-36591
+                             sym-36999
+                             (cdr subst-37000)
+                             marks-37001
+                             mod-37004)
+                           (if (if (eq? (vector-ref symnames-37002 i-37009)
+                                        sym-36999)
+                                 (same-marks?-4364
+                                   marks-37001
                                    (vector-ref
-                                     (vector-ref ribcage-36768 2)
-                                     i-36774))
+                                     (vector-ref ribcage-37003 2)
+                                     i-37009))
                                  #f)
-                             (let ((n-36921
+                             (let ((n-37156
                                      (vector-ref
-                                       (vector-ref ribcage-36768 3)
-                                       i-36774)))
-                               (if (pair? n-36921)
-                                 (if (equal? mod-36769 (car n-36921))
-                                   (values (cdr n-36921) marks-36766)
-                                   (f-36771 (#{1+}# i-36774)))
-                                 (values n-36921 marks-36766)))
-                             (f-36771 (#{1+}# i-36774)))))))
-                    (f-36771 0))))))
-           (if (symbol? id-36353)
-             (let ((t-36359
-                     (search-36356
-                       id-36353
-                       (cdr w-36354)
-                       (car w-36354)
-                       mod-36355)))
-               (if t-36359 t-36359 id-36353))
-             (if (if (vector? id-36353)
-                   (if (= (vector-length id-36353) 4)
-                     (eq? (vector-ref id-36353 0) 'syntax-object)
+                                       (vector-ref ribcage-37003 3)
+                                       i-37009)))
+                               (if (pair? n-37156)
+                                 (if (equal? mod-37004 (car n-37156))
+                                   (values (cdr n-37156) marks-37001)
+                                   (f-37006 (#{1+}# i-37009)))
+                                 (values n-37156 marks-37001)))
+                             (f-37006 (#{1+}# i-37009)))))))
+                    (f-37006 0))))))
+           (if (symbol? id-36588)
+             (let ((t-36594
+                     (search-36591
+                       id-36588
+                       (cdr w-36589)
+                       (car w-36589)
+                       mod-36590)))
+               (if t-36594 t-36594 id-36588))
+             (if (if (vector? id-36588)
+                   (if (= (vector-length id-36588) 4)
+                     (eq? (vector-ref id-36588 0) 'syntax-object)
                      #f)
                    #f)
-               (let ((id-36374 (vector-ref id-36353 1))
-                     (w1-36375 (vector-ref id-36353 2))
-                     (mod-36376 (vector-ref id-36353 3)))
-                 (let ((marks-36377
-                         (let ((m1-36387 (car w-36354))
-                               (m2-36388 (car w1-36375)))
-                           (if (null? m2-36388)
-                             m1-36387
-                             (append m1-36387 m2-36388)))))
+               (let ((id-36609 (vector-ref id-36588 1))
+                     (w1-36610 (vector-ref id-36588 2))
+                     (mod-36611 (vector-ref id-36588 3)))
+                 (let ((marks-36612
+                         (let ((m1-36622 (car w-36589))
+                               (m2-36623 (car w1-36610)))
+                           (if (null? m2-36623)
+                             m1-36622
+                             (append m1-36622 m2-36623)))))
                    (call-with-values
                      (lambda ()
-                       (search-36356
-                         id-36374
-                         (cdr w-36354)
-                         marks-36377
-                         mod-36376))
-                     (lambda (new-id-36408 marks-36409)
-                       (if new-id-36408
-                         new-id-36408
-                         (let ((t-36417
-                                 (search-36356
-                                   id-36374
-                                   (cdr w1-36375)
-                                   marks-36409
-                                   mod-36376)))
-                           (if t-36417 t-36417 id-36374)))))))
+                       (search-36591
+                         id-36609
+                         (cdr w-36589)
+                         marks-36612
+                         mod-36611))
+                     (lambda (new-id-36643 marks-36644)
+                       (if new-id-36643
+                         new-id-36643
+                         (let ((t-36652
+                                 (search-36591
+                                   id-36609
+                                   (cdr w1-36610)
+                                   marks-36644
+                                   mod-36611)))
+                           (if t-36652 t-36652 id-36609)))))))
                (syntax-violation
                  'id-var-name
                  "invalid id"
-                 id-36353))))))
-     (locally-bound-identifiers-4570
-       (lambda (w-19391 mod-19392)
+                 id-36588))))))
+     (locally-bound-identifiers-4366
+       (lambda (w-19494 mod-19495)
          (letrec*
-           ((scan-19393
-              (lambda (subst-19398 results-19399)
-                (if (null? subst-19398)
-                  results-19399
-                  (let ((fst-19400 (car subst-19398)))
-                    (if (eq? fst-19400 'shift)
-                      (scan-19393 (cdr subst-19398) results-19399)
-                      (let ((symnames-19402 (vector-ref fst-19400 1))
-                            (marks-19403 (vector-ref fst-19400 2)))
-                        (if (vector? symnames-19402)
-                          (scan-vector-rib-19395
-                            subst-19398
-                            symnames-19402
-                            marks-19403
-                            results-19399)
-                          (scan-list-rib-19394
-                            subst-19398
-                            symnames-19402
-                            marks-19403
-                            results-19399))))))))
-            (scan-list-rib-19394
-              (lambda (subst-19520
-                       symnames-19521
-                       marks-19522
-                       results-19523)
+           ((scan-19496
+              (lambda (subst-19501 results-19502)
+                (if (null? subst-19501)
+                  results-19502
+                  (let ((fst-19503 (car subst-19501)))
+                    (if (eq? fst-19503 'shift)
+                      (scan-19496 (cdr subst-19501) results-19502)
+                      (let ((symnames-19505 (vector-ref fst-19503 1))
+                            (marks-19506 (vector-ref fst-19503 2)))
+                        (if (vector? symnames-19505)
+                          (scan-vector-rib-19498
+                            subst-19501
+                            symnames-19505
+                            marks-19506
+                            results-19502)
+                          (scan-list-rib-19497
+                            subst-19501
+                            symnames-19505
+                            marks-19506
+                            results-19502))))))))
+            (scan-list-rib-19497
+              (lambda (subst-19623
+                       symnames-19624
+                       marks-19625
+                       results-19626)
                 (letrec*
-                  ((f-19524
-                     (lambda (symnames-19709 marks-19710 results-19711)
-                       (if (null? symnames-19709)
-                         (scan-19393 (cdr subst-19520) results-19711)
-                         (f-19524
-                           (cdr symnames-19709)
-                           (cdr marks-19710)
-                           (cons (let ((x-19717 (car symnames-19709))
-                                       (w-19718
-                                         (let ((w-19722
-                                                 (cons (car marks-19710)
-                                                       subst-19520)))
-                                           (cons (cons #f (car w-19722))
+                  ((f-19627
+                     (lambda (symnames-19812 marks-19813 results-19814)
+                       (if (null? symnames-19812)
+                         (scan-19496 (cdr subst-19623) results-19814)
+                         (f-19627
+                           (cdr symnames-19812)
+                           (cdr marks-19813)
+                           (cons (let ((x-19820 (car symnames-19812))
+                                       (w-19821
+                                         (let ((w-19825
+                                                 (cons (car marks-19813)
+                                                       subst-19623)))
+                                           (cons (cons #f (car w-19825))
                                                  (cons 'shift
-                                                       (cdr w-19722))))))
-                                   (if (if (null? (car w-19718))
-                                         (null? (cdr w-19718))
+                                                       (cdr w-19825))))))
+                                   (if (if (null? (car w-19821))
+                                         (null? (cdr w-19821))
                                          #f)
-                                     x-19717
-                                     (if (if (vector? x-19717)
-                                           (if (= (vector-length x-19717) 4)
-                                             (eq? (vector-ref x-19717 0)
+                                     x-19820
+                                     (if (if (vector? x-19820)
+                                           (if (= (vector-length x-19820) 4)
+                                             (eq? (vector-ref x-19820 0)
                                                   'syntax-object)
                                              #f)
                                            #f)
-                                       (let ((expression-19734
-                                               (vector-ref x-19717 1))
-                                             (wrap-19735
-                                               (let ((w2-19743
-                                                       (vector-ref x-19717 2)))
-                                                 (let ((m1-19744 (car w-19718))
-                                                       (s1-19745
-                                                         (cdr w-19718)))
-                                                   (if (null? m1-19744)
-                                                     (if (null? s1-19745)
-                                                       w2-19743
-                                                       (cons (car w2-19743)
-                                                             (let ((m2-19756
-                                                                     (cdr 
w2-19743)))
-                                                               (if (null? 
m2-19756)
-                                                                 s1-19745
+                                       (let ((expression-19837
+                                               (vector-ref x-19820 1))
+                                             (wrap-19838
+                                               (let ((w2-19846
+                                                       (vector-ref x-19820 2)))
+                                                 (let ((m1-19847 (car w-19821))
+                                                       (s1-19848
+                                                         (cdr w-19821)))
+                                                   (if (null? m1-19847)
+                                                     (if (null? s1-19848)
+                                                       w2-19846
+                                                       (cons (car w2-19846)
+                                                             (let ((m2-19859
+                                                                     (cdr 
w2-19846)))
+                                                               (if (null? 
m2-19859)
+                                                                 s1-19848
                                                                  (append
-                                                                   s1-19745
-                                                                   
m2-19756)))))
-                                                     (cons (let ((m2-19764
-                                                                   (car 
w2-19743)))
-                                                             (if (null? 
m2-19764)
-                                                               m1-19744
+                                                                   s1-19848
+                                                                   
m2-19859)))))
+                                                     (cons (let ((m2-19867
+                                                                   (car 
w2-19846)))
+                                                             (if (null? 
m2-19867)
+                                                               m1-19847
                                                                (append
-                                                                 m1-19744
-                                                                 m2-19764)))
-                                                           (let ((m2-19772
-                                                                   (cdr 
w2-19743)))
-                                                             (if (null? 
m2-19772)
-                                                               s1-19745
+                                                                 m1-19847
+                                                                 m2-19867)))
+                                                           (let ((m2-19875
+                                                                   (cdr 
w2-19846)))
+                                                             (if (null? 
m2-19875)
+                                                               s1-19848
                                                                (append
-                                                                 s1-19745
-                                                                 
m2-19772))))))))
-                                             (module-19736
-                                               (vector-ref x-19717 3)))
+                                                                 s1-19848
+                                                                 
m2-19875))))))))
+                                             (module-19839
+                                               (vector-ref x-19820 3)))
                                          (vector
                                            'syntax-object
-                                           expression-19734
-                                           wrap-19735
-                                           module-19736))
-                                       (if (null? x-19717)
-                                         x-19717
+                                           expression-19837
+                                           wrap-19838
+                                           module-19839))
+                                       (if (null? x-19820)
+                                         x-19820
                                          (vector
                                            'syntax-object
-                                           x-19717
-                                           w-19718
-                                           mod-19392)))))
-                                 results-19711))))))
-                  (f-19524
-                    symnames-19521
-                    marks-19522
-                    results-19523))))
-            (scan-vector-rib-19395
-              (lambda (subst-19785
-                       symnames-19786
-                       marks-19787
-                       results-19788)
-                (let ((n-19789 (vector-length symnames-19786)))
+                                           x-19820
+                                           w-19821
+                                           mod-19495)))))
+                                 results-19814))))))
+                  (f-19627
+                    symnames-19624
+                    marks-19625
+                    results-19626))))
+            (scan-vector-rib-19498
+              (lambda (subst-19888
+                       symnames-19889
+                       marks-19890
+                       results-19891)
+                (let ((n-19892 (vector-length symnames-19889)))
                   (letrec*
-                    ((f-19790
-                       (lambda (i-19961 results-19962)
-                         (if (= i-19961 n-19789)
-                           (scan-19393 (cdr subst-19785) results-19962)
-                           (f-19790
-                             (#{1+}# i-19961)
-                             (cons (let ((x-19968
-                                           (vector-ref symnames-19786 i-19961))
-                                         (w-19969
-                                           (let ((w-19973
+                    ((f-19893
+                       (lambda (i-20064 results-20065)
+                         (if (= i-20064 n-19892)
+                           (scan-19496 (cdr subst-19888) results-20065)
+                           (f-19893
+                             (#{1+}# i-20064)
+                             (cons (let ((x-20071
+                                           (vector-ref symnames-19889 i-20064))
+                                         (w-20072
+                                           (let ((w-20076
                                                    (cons (vector-ref
-                                                           marks-19787
-                                                           i-19961)
-                                                         subst-19785)))
-                                             (cons (cons #f (car w-19973))
+                                                           marks-19890
+                                                           i-20064)
+                                                         subst-19888)))
+                                             (cons (cons #f (car w-20076))
                                                    (cons 'shift
-                                                         (cdr w-19973))))))
-                                     (if (if (null? (car w-19969))
-                                           (null? (cdr w-19969))
+                                                         (cdr w-20076))))))
+                                     (if (if (null? (car w-20072))
+                                           (null? (cdr w-20072))
                                            #f)
-                                       x-19968
-                                       (if (if (vector? x-19968)
-                                             (if (= (vector-length x-19968) 4)
-                                               (eq? (vector-ref x-19968 0)
+                                       x-20071
+                                       (if (if (vector? x-20071)
+                                             (if (= (vector-length x-20071) 4)
+                                               (eq? (vector-ref x-20071 0)
                                                     'syntax-object)
                                                #f)
                                              #f)
-                                         (let ((expression-19985
-                                                 (vector-ref x-19968 1))
-                                               (wrap-19986
-                                                 (let ((w2-19994
+                                         (let ((expression-20088
+                                                 (vector-ref x-20071 1))
+                                               (wrap-20089
+                                                 (let ((w2-20097
                                                          (vector-ref
-                                                           x-19968
+                                                           x-20071
                                                            2)))
-                                                   (let ((m1-19995
-                                                           (car w-19969))
-                                                         (s1-19996
-                                                           (cdr w-19969)))
-                                                     (if (null? m1-19995)
-                                                       (if (null? s1-19996)
-                                                         w2-19994
-                                                         (cons (car w2-19994)
-                                                               (let ((m2-20007
-                                                                       (cdr 
w2-19994)))
-                                                                 (if (null? 
m2-20007)
-                                                                   s1-19996
+                                                   (let ((m1-20098
+                                                           (car w-20072))
+                                                         (s1-20099
+                                                           (cdr w-20072)))
+                                                     (if (null? m1-20098)
+                                                       (if (null? s1-20099)
+                                                         w2-20097
+                                                         (cons (car w2-20097)
+                                                               (let ((m2-20110
+                                                                       (cdr 
w2-20097)))
+                                                                 (if (null? 
m2-20110)
+                                                                   s1-20099
                                                                    (append
-                                                                     s1-19996
-                                                                     
m2-20007)))))
-                                                       (cons (let ((m2-20015
-                                                                     (car 
w2-19994)))
-                                                               (if (null? 
m2-20015)
-                                                                 m1-19995
+                                                                     s1-20099
+                                                                     
m2-20110)))))
+                                                       (cons (let ((m2-20118
+                                                                     (car 
w2-20097)))
+                                                               (if (null? 
m2-20118)
+                                                                 m1-20098
                                                                  (append
-                                                                   m1-19995
-                                                                   m2-20015)))
-                                                             (let ((m2-20023
-                                                                     (cdr 
w2-19994)))
-                                                               (if (null? 
m2-20023)
-                                                                 s1-19996
+                                                                   m1-20098
+                                                                   m2-20118)))
+                                                             (let ((m2-20126
+                                                                     (cdr 
w2-20097)))
+                                                               (if (null? 
m2-20126)
+                                                                 s1-20099
                                                                  (append
-                                                                   s1-19996
-                                                                   
m2-20023))))))))
-                                               (module-19987
-                                                 (vector-ref x-19968 3)))
+                                                                   s1-20099
+                                                                   
m2-20126))))))))
+                                               (module-20090
+                                                 (vector-ref x-20071 3)))
                                            (vector
                                              'syntax-object
-                                             expression-19985
-                                             wrap-19986
-                                             module-19987))
-                                         (if (null? x-19968)
-                                           x-19968
+                                             expression-20088
+                                             wrap-20089
+                                             module-20090))
+                                         (if (null? x-20071)
+                                           x-20071
                                            (vector
                                              'syntax-object
-                                             x-19968
-                                             w-19969
-                                             mod-19392)))))
-                                   results-19962))))))
-                    (f-19790 0 results-19788))))))
-           (scan-19393 (cdr w-19391) '()))))
-     (resolve-identifier-4571
-       (lambda (id-20036
-                w-20037
-                r-20038
-                mod-20039
-                resolve-syntax-parameters?-20040)
-         (let ((n-20044
-                 (id-var-name-4569 id-20036 w-20037 mod-20039)))
-           (if (if (vector? n-20044)
-                 (if (= (vector-length n-20044) 4)
-                   (eq? (vector-ref n-20044 0) 'syntax-object)
+                                             x-20071
+                                             w-20072
+                                             mod-19495)))))
+                                   results-20065))))))
+                    (f-19893 0 results-19891))))))
+           (scan-19496 (cdr w-19494) '()))))
+     (resolve-identifier-4367
+       (lambda (id-20139
+                w-20140
+                r-20141
+                mod-20142
+                resolve-syntax-parameters?-20143)
+         (let ((n-20147
+                 (id-var-name-4365 id-20139 w-20140 mod-20142)))
+           (if (if (vector? n-20147)
+                 (if (= (vector-length n-20147) 4)
+                   (eq? (vector-ref n-20147 0) 'syntax-object)
                    #f)
                  #f)
-             (resolve-identifier-4571
-               n-20044
-               w-20037
-               r-20038
-               mod-20039
-               resolve-syntax-parameters?-20040)
-             (if (symbol? n-20044)
-               (let ((mod-20059
-                       (if (if (vector? id-20036)
-                             (if (= (vector-length id-20036) 4)
-                               (eq? (vector-ref id-20036 0) 'syntax-object)
+             (resolve-identifier-4367
+               n-20147
+               w-20140
+               r-20141
+               mod-20142
+               resolve-syntax-parameters?-20143)
+             (if (symbol? n-20147)
+               (let ((mod-20162
+                       (if (if (vector? id-20139)
+                             (if (= (vector-length id-20139) 4)
+                               (eq? (vector-ref id-20139 0) 'syntax-object)
                                #f)
                              #f)
-                         (vector-ref id-20036 3)
-                         mod-20039)))
-                 (let ((b-20060
-                         (let ((b-20063
-                                 (let ((t-20064
+                         (vector-ref id-20139 3)
+                         mod-20142)))
+                 (let ((b-20163
+                         (let ((b-20166
+                                 (let ((t-20167
                                          (begin
-                                           (if (if (not mod-20059)
+                                           (if (if (not mod-20162)
                                                  (current-module)
                                                  #f)
                                              (warn "module system is booted, 
we should have a module"
-                                                   n-20044))
-                                           (let ((v-20113
+                                                   n-20147))
+                                           (let ((v-20216
                                                    (module-variable
-                                                     (if mod-20059
+                                                     (if mod-20162
                                                        (resolve-module
-                                                         (cdr mod-20059))
+                                                         (cdr mod-20162))
                                                        (current-module))
-                                                     n-20044)))
-                                             (if v-20113
-                                               (if (variable-bound? v-20113)
-                                                 (let ((val-20122
+                                                     n-20147)))
+                                             (if v-20216
+                                               (if (variable-bound? v-20216)
+                                                 (let ((val-20225
                                                          (variable-ref
-                                                           v-20113)))
-                                                   (if (macro? val-20122)
-                                                     (if (macro-type val-20122)
+                                                           v-20216)))
+                                                   (if (macro? val-20225)
+                                                     (if (macro-type val-20225)
                                                        (cons (macro-type
-                                                               val-20122)
+                                                               val-20225)
                                                              (macro-binding
-                                                               val-20122))
+                                                               val-20225))
                                                        #f)
                                                      #f))
                                                  #f)
                                                #f)))))
-                                   (if t-20064 t-20064 '(global)))))
-                           (if (if resolve-syntax-parameters?-20040
-                                 (eq? (car b-20063) 'syntax-parameter)
+                                   (if t-20167 t-20167 '(global)))))
+                           (if (if resolve-syntax-parameters?-20143
+                                 (eq? (car b-20166) 'syntax-parameter)
                                  #f)
-                             (let ((t-20131 (assq-ref r-20038 (cdr b-20063))))
-                               (if t-20131
-                                 t-20131
-                                 (cons 'macro (car (cdr b-20063)))))
-                             b-20063))))
-                   (if (eq? (car b-20060) 'global)
-                     (values 'global n-20044 mod-20059)
-                     (values (car b-20060) (cdr b-20060) mod-20059))))
-               (if (string? n-20044)
-                 (let ((mod-20137
-                         (if (if (vector? id-20036)
-                               (if (= (vector-length id-20036) 4)
-                                 (eq? (vector-ref id-20036 0) 'syntax-object)
+                             (let ((t-20234 (assq-ref r-20141 (cdr b-20166))))
+                               (if t-20234
+                                 t-20234
+                                 (cons 'macro (car (cdr b-20166)))))
+                             b-20166))))
+                   (if (eq? (car b-20163) 'global)
+                     (values 'global n-20147 mod-20162)
+                     (values (car b-20163) (cdr b-20163) mod-20162))))
+               (if (string? n-20147)
+                 (let ((mod-20240
+                         (if (if (vector? id-20139)
+                               (if (= (vector-length id-20139) 4)
+                                 (eq? (vector-ref id-20139 0) 'syntax-object)
                                  #f)
                                #f)
-                           (vector-ref id-20036 3)
-                           mod-20039)))
-                   (let ((b-20138
-                           (let ((b-20141
-                                   (let ((t-20142 (assq-ref r-20038 n-20044)))
-                                     (if t-20142
-                                       t-20142
+                           (vector-ref id-20139 3)
+                           mod-20142)))
+                   (let ((b-20241
+                           (let ((b-20244
+                                   (let ((t-20245 (assq-ref r-20141 n-20147)))
+                                     (if t-20245
+                                       t-20245
                                        '(displaced-lexical)))))
-                             (if (if resolve-syntax-parameters?-20040
-                                   (eq? (car b-20141) 'syntax-parameter)
+                             (if (if resolve-syntax-parameters?-20143
+                                   (eq? (car b-20244) 'syntax-parameter)
                                    #f)
-                               (let ((t-20143
-                                       (assq-ref r-20038 (cdr b-20141))))
-                                 (if t-20143
-                                   t-20143
-                                   (cons 'macro (car (cdr b-20141)))))
-                               b-20141))))
-                     (values (car b-20138) (cdr b-20138) mod-20137)))
+                               (let ((t-20246
+                                       (assq-ref r-20141 (cdr b-20244))))
+                                 (if t-20246
+                                   t-20246
+                                   (cons 'macro (car (cdr b-20244)))))
+                               b-20244))))
+                     (values (car b-20241) (cdr b-20241) mod-20240)))
                  (error "unexpected id-var-name"
-                        id-20036
-                        w-20037
-                        n-20044)))))))
-     (free-id=?-4574
-       (lambda (i-20156 j-20157)
-         (let ((mi-20158
-                 (if (if (vector? i-20156)
-                       (if (= (vector-length i-20156) 4)
-                         (eq? (vector-ref i-20156 0) 'syntax-object)
+                        id-20139
+                        w-20140
+                        n-20147)))))))
+     (free-id=?-4370
+       (lambda (i-20259 j-20260)
+         (let ((mi-20261
+                 (if (if (vector? i-20259)
+                       (if (= (vector-length i-20259) 4)
+                         (eq? (vector-ref i-20259 0) 'syntax-object)
                          #f)
                        #f)
-                   (vector-ref i-20156 3)
+                   (vector-ref i-20259 3)
                    #f)))
-           (let ((mj-20159
-                   (if (if (vector? j-20157)
-                         (if (= (vector-length j-20157) 4)
-                           (eq? (vector-ref j-20157 0) 'syntax-object)
+           (let ((mj-20262
+                   (if (if (vector? j-20260)
+                         (if (= (vector-length j-20260) 4)
+                           (eq? (vector-ref j-20260 0) 'syntax-object)
                            #f)
                          #f)
-                     (vector-ref j-20157 3)
+                     (vector-ref j-20260 3)
                      #f)))
-             (let ((ni-20160
-                     (id-var-name-4569 i-20156 '(()) mi-20158)))
-               (let ((nj-20161
-                       (id-var-name-4569 j-20157 '(()) mj-20159)))
-                 (if (if (vector? ni-20160)
-                       (if (= (vector-length ni-20160) 4)
-                         (eq? (vector-ref ni-20160 0) 'syntax-object)
+             (let ((ni-20263
+                     (id-var-name-4365 i-20259 '(()) mi-20261)))
+               (let ((nj-20264
+                       (id-var-name-4365 j-20260 '(()) mj-20262)))
+                 (if (if (vector? ni-20263)
+                       (if (= (vector-length ni-20263) 4)
+                         (eq? (vector-ref ni-20263 0) 'syntax-object)
                          #f)
                        #f)
-                   (free-id=?-4574 ni-20160 j-20157)
-                   (if (if (vector? nj-20161)
-                         (if (= (vector-length nj-20161) 4)
-                           (eq? (vector-ref nj-20161 0) 'syntax-object)
+                   (free-id=?-4370 ni-20263 j-20260)
+                   (if (if (vector? nj-20264)
+                         (if (= (vector-length nj-20264) 4)
+                           (eq? (vector-ref nj-20264 0) 'syntax-object)
                            #f)
                          #f)
-                     (free-id=?-4574 i-20156 nj-20161)
-                     (if (symbol? ni-20160)
-                       (if (eq? nj-20161
-                                (if (if (vector? j-20157)
-                                      (if (= (vector-length j-20157) 4)
-                                        (eq? (vector-ref j-20157 0)
+                     (free-id=?-4370 i-20259 nj-20264)
+                     (if (symbol? ni-20263)
+                       (if (eq? nj-20264
+                                (if (if (vector? j-20260)
+                                      (if (= (vector-length j-20260) 4)
+                                        (eq? (vector-ref j-20260 0)
                                              'syntax-object)
                                         #f)
                                       #f)
-                                  (vector-ref j-20157 1)
-                                  j-20157))
-                         (if (let ((bi-20233
+                                  (vector-ref j-20260 1)
+                                  j-20260))
+                         (if (let ((bi-20336
                                      (module-variable
-                                       (if mi-20158
-                                         (resolve-module (cdr mi-20158))
+                                       (if mi-20261
+                                         (resolve-module (cdr mi-20261))
                                          (current-module))
-                                       (if (if (vector? i-20156)
-                                             (if (= (vector-length i-20156) 4)
-                                               (eq? (vector-ref i-20156 0)
+                                       (if (if (vector? i-20259)
+                                             (if (= (vector-length i-20259) 4)
+                                               (eq? (vector-ref i-20259 0)
                                                     'syntax-object)
                                                #f)
                                              #f)
-                                         (vector-ref i-20156 1)
-                                         i-20156))))
-                               (if bi-20233
-                                 (eq? bi-20233
+                                         (vector-ref i-20259 1)
+                                         i-20259))))
+                               (if bi-20336
+                                 (eq? bi-20336
                                       (module-variable
-                                        (if mj-20159
-                                          (resolve-module (cdr mj-20159))
+                                        (if mj-20262
+                                          (resolve-module (cdr mj-20262))
                                           (current-module))
-                                        (if (if (vector? j-20157)
-                                              (if (= (vector-length j-20157) 4)
-                                                (eq? (vector-ref j-20157 0)
+                                        (if (if (vector? j-20260)
+                                              (if (= (vector-length j-20260) 4)
+                                                (eq? (vector-ref j-20260 0)
                                                      'syntax-object)
                                                 #f)
                                               #f)
-                                          (vector-ref j-20157 1)
-                                          j-20157)))
+                                          (vector-ref j-20260 1)
+                                          j-20260)))
                                  (if (not (module-variable
-                                            (if mj-20159
-                                              (resolve-module (cdr mj-20159))
+                                            (if mj-20262
+                                              (resolve-module (cdr mj-20262))
                                               (current-module))
-                                            (if (if (vector? j-20157)
+                                            (if (if (vector? j-20260)
                                                   (if (= (vector-length
-                                                           j-20157)
+                                                           j-20260)
                                                          4)
-                                                    (eq? (vector-ref j-20157 0)
+                                                    (eq? (vector-ref j-20260 0)
                                                          'syntax-object)
                                                     #f)
                                                   #f)
-                                              (vector-ref j-20157 1)
-                                              j-20157)))
-                                   (eq? ni-20160 nj-20161)
+                                              (vector-ref j-20260 1)
+                                              j-20260)))
+                                   (eq? ni-20263 nj-20264)
                                    #f)))
                            (eq? (module-variable
-                                  (if mi-20158
-                                    (resolve-module (cdr mi-20158))
+                                  (if mi-20261
+                                    (resolve-module (cdr mi-20261))
                                     (current-module))
-                                  (if (if (vector? i-20156)
-                                        (if (= (vector-length i-20156) 4)
-                                          (eq? (vector-ref i-20156 0)
+                                  (if (if (vector? i-20259)
+                                        (if (= (vector-length i-20259) 4)
+                                          (eq? (vector-ref i-20259 0)
                                                'syntax-object)
                                           #f)
                                         #f)
-                                    (vector-ref i-20156 1)
-                                    i-20156))
+                                    (vector-ref i-20259 1)
+                                    i-20259))
                                 (module-variable
-                                  (if mj-20159
-                                    (resolve-module (cdr mj-20159))
+                                  (if mj-20262
+                                    (resolve-module (cdr mj-20262))
                                     (current-module))
-                                  (if (if (vector? j-20157)
-                                        (if (= (vector-length j-20157) 4)
-                                          (eq? (vector-ref j-20157 0)
+                                  (if (if (vector? j-20260)
+                                        (if (= (vector-length j-20260) 4)
+                                          (eq? (vector-ref j-20260 0)
                                                'syntax-object)
                                           #f)
                                         #f)
-                                    (vector-ref j-20157 1)
-                                    j-20157)))
+                                    (vector-ref j-20260 1)
+                                    j-20260)))
                            #f)
                          #f)
-                       (equal? ni-20160 nj-20161))))))))))
-     (bound-id=?-4575
-       (lambda (i-20426 j-20427)
-         (if (if (if (vector? i-20426)
-                   (if (= (vector-length i-20426) 4)
-                     (eq? (vector-ref i-20426 0) 'syntax-object)
+                       (equal? ni-20263 nj-20264))))))))))
+     (bound-id=?-4371
+       (lambda (i-20529 j-20530)
+         (if (if (if (vector? i-20529)
+                   (if (= (vector-length i-20529) 4)
+                     (eq? (vector-ref i-20529 0) 'syntax-object)
                      #f)
                    #f)
-               (if (vector? j-20427)
-                 (if (= (vector-length j-20427) 4)
-                   (eq? (vector-ref j-20427 0) 'syntax-object)
+               (if (vector? j-20530)
+                 (if (= (vector-length j-20530) 4)
+                   (eq? (vector-ref j-20530 0) 'syntax-object)
                    #f)
                  #f)
                #f)
-           (if (eq? (vector-ref i-20426 1)
-                    (vector-ref j-20427 1))
-             (same-marks?-4568
-               (car (vector-ref i-20426 2))
-               (car (vector-ref j-20427 2)))
+           (if (eq? (vector-ref i-20529 1)
+                    (vector-ref j-20530 1))
+             (same-marks?-4364
+               (car (vector-ref i-20529 2))
+               (car (vector-ref j-20530 2)))
              #f)
-           (eq? i-20426 j-20427))))
-     (valid-bound-ids?-4576
-       (lambda (ids-20596)
+           (eq? i-20529 j-20530))))
+     (valid-bound-ids?-4372
+       (lambda (ids-20699)
          (if (letrec*
-               ((all-ids?-20597
-                  (lambda (ids-20794)
-                    (if (null? ids-20794)
-                      (null? ids-20794)
-                      (if (let ((x-20805 (car ids-20794)))
-                            (if (symbol? x-20805)
+               ((all-ids?-20700
+                  (lambda (ids-20897)
+                    (if (null? ids-20897)
+                      (null? ids-20897)
+                      (if (let ((x-20908 (car ids-20897)))
+                            (if (symbol? x-20908)
                               #t
-                              (if (if (vector? x-20805)
-                                    (if (= (vector-length x-20805) 4)
-                                      (eq? (vector-ref x-20805 0)
+                              (if (if (vector? x-20908)
+                                    (if (= (vector-length x-20908) 4)
+                                      (eq? (vector-ref x-20908 0)
                                            'syntax-object)
                                       #f)
                                     #f)
-                                (symbol? (vector-ref x-20805 1))
+                                (symbol? (vector-ref x-20908 1))
                                 #f)))
-                        (all-ids?-20597 (cdr ids-20794))
+                        (all-ids?-20700 (cdr ids-20897))
                         #f)))))
-               (all-ids?-20597 ids-20596))
-           (distinct-bound-ids?-4577 ids-20596)
+               (all-ids?-20700 ids-20699))
+           (distinct-bound-ids?-4373 ids-20699)
            #f)))
-     (distinct-bound-ids?-4577
-       (lambda (ids-20926)
+     (distinct-bound-ids?-4373
+       (lambda (ids-21029)
          (letrec*
-           ((distinct?-20927
-              (lambda (ids-21032)
-                (if (null? ids-21032)
-                  (null? ids-21032)
-                  (if (not (bound-id-member?-4578
-                             (car ids-21032)
-                             (cdr ids-21032)))
-                    (distinct?-20927 (cdr ids-21032))
+           ((distinct?-21030
+              (lambda (ids-21135)
+                (if (null? ids-21135)
+                  (null? ids-21135)
+                  (if (not (bound-id-member?-4374
+                             (car ids-21135)
+                             (cdr ids-21135)))
+                    (distinct?-21030 (cdr ids-21135))
                     #f)))))
-           (distinct?-20927 ids-20926))))
-     (bound-id-member?-4578
-       (lambda (x-21128 list-21129)
-         (if (not (null? list-21129))
-           (let ((t-21130
-                   (bound-id=?-4575 x-21128 (car list-21129))))
-             (if t-21130
-               t-21130
-               (bound-id-member?-4578 x-21128 (cdr list-21129))))
+           (distinct?-21030 ids-21029))))
+     (bound-id-member?-4374
+       (lambda (x-21231 list-21232)
+         (if (not (null? list-21232))
+           (let ((t-21233
+                   (bound-id=?-4371 x-21231 (car list-21232))))
+             (if t-21233
+               t-21233
+               (bound-id-member?-4374 x-21231 (cdr list-21232))))
            #f)))
-     (source-wrap-4580
-       (lambda (x-21308 w-21309 s-21310 defmod-21311)
-         (let ((x-21315
+     (source-wrap-4376
+       (lambda (x-21411 w-21412 s-21413 defmod-21414)
+         (let ((x-21418
                  (begin
-                   (if (if (pair? x-21308) s-21310 #f)
-                     (set-source-properties! x-21308 s-21310))
-                   x-21308)))
-           (if (if (null? (car w-21309))
-                 (null? (cdr w-21309))
+                   (if (if (pair? x-21411) s-21413 #f)
+                     (set-source-properties! x-21411 s-21413))
+                   x-21411)))
+           (if (if (null? (car w-21412))
+                 (null? (cdr w-21412))
                  #f)
-             x-21315
-             (if (if (vector? x-21315)
-                   (if (= (vector-length x-21315) 4)
-                     (eq? (vector-ref x-21315 0) 'syntax-object)
+             x-21418
+             (if (if (vector? x-21418)
+                   (if (= (vector-length x-21418) 4)
+                     (eq? (vector-ref x-21418 0) 'syntax-object)
                      #f)
                    #f)
-               (let ((expression-21347 (vector-ref x-21315 1))
-                     (wrap-21348
-                       (let ((w2-21356 (vector-ref x-21315 2)))
-                         (let ((m1-21357 (car w-21309))
-                               (s1-21358 (cdr w-21309)))
-                           (if (null? m1-21357)
-                             (if (null? s1-21358)
-                               w2-21356
-                               (cons (car w2-21356)
-                                     (let ((m2-21373 (cdr w2-21356)))
-                                       (if (null? m2-21373)
-                                         s1-21358
-                                         (append s1-21358 m2-21373)))))
-                             (cons (let ((m2-21381 (car w2-21356)))
-                                     (if (null? m2-21381)
-                                       m1-21357
-                                       (append m1-21357 m2-21381)))
-                                   (let ((m2-21389 (cdr w2-21356)))
-                                     (if (null? m2-21389)
-                                       s1-21358
-                                       (append s1-21358 m2-21389))))))))
-                     (module-21349 (vector-ref x-21315 3)))
+               (let ((expression-21450 (vector-ref x-21418 1))
+                     (wrap-21451
+                       (let ((w2-21459 (vector-ref x-21418 2)))
+                         (let ((m1-21460 (car w-21412))
+                               (s1-21461 (cdr w-21412)))
+                           (if (null? m1-21460)
+                             (if (null? s1-21461)
+                               w2-21459
+                               (cons (car w2-21459)
+                                     (let ((m2-21476 (cdr w2-21459)))
+                                       (if (null? m2-21476)
+                                         s1-21461
+                                         (append s1-21461 m2-21476)))))
+                             (cons (let ((m2-21484 (car w2-21459)))
+                                     (if (null? m2-21484)
+                                       m1-21460
+                                       (append m1-21460 m2-21484)))
+                                   (let ((m2-21492 (cdr w2-21459)))
+                                     (if (null? m2-21492)
+                                       s1-21461
+                                       (append s1-21461 m2-21492))))))))
+                     (module-21452 (vector-ref x-21418 3)))
                  (vector
                    'syntax-object
-                   expression-21347
-                   wrap-21348
-                   module-21349))
-               (if (null? x-21315)
-                 x-21315
+                   expression-21450
+                   wrap-21451
+                   module-21452))
+               (if (null? x-21418)
+                 x-21418
                  (vector
                    'syntax-object
-                   x-21315
-                   w-21309
-                   defmod-21311)))))))
-     (expand-sequence-4581
-       (lambda (body-36926 r-36927 w-36928 s-36929 mod-36930)
-         (build-sequence-4532
-           s-36929
+                   x-21418
+                   w-21412
+                   defmod-21414)))))))
+     (expand-sequence-4377
+       (lambda (body-37161 r-37162 w-37163 s-37164 mod-37165)
+         (build-sequence-4328
+           s-37164
            (letrec*
-             ((dobody-37018
-                (lambda (body-37101 r-37102 w-37103 mod-37104)
-                  (if (null? body-37101)
+             ((dobody-37253
+                (lambda (body-37336 r-37337 w-37338 mod-37339)
+                  (if (null? body-37336)
                     '()
-                    (let ((first-37105
-                            (expand-4586
-                              (car body-37101)
-                              r-37102
-                              w-37103
-                              mod-37104)))
-                      (cons first-37105
-                            (dobody-37018
-                              (cdr body-37101)
-                              r-37102
-                              w-37103
-                              mod-37104)))))))
-             (dobody-37018
-               body-36926
-               r-36927
-               w-36928
-               mod-36930)))))
-     (expand-top-sequence-4582
-       (lambda (body-21418
-                r-21419
-                w-21420
-                s-21421
-                m-21422
-                esew-21423
-                mod-21424)
-         (let ((r-21425
-                 (cons '("placeholder" placeholder) r-21419)))
-           (let ((ribcage-21426 (vector 'ribcage '() '() '())))
-             (let ((w-21427
-                     (cons (car w-21420)
-                           (cons ribcage-21426 (cdr w-21420)))))
+                    (let ((first-37340
+                            (expand-4382
+                              (car body-37336)
+                              r-37337
+                              w-37338
+                              mod-37339)))
+                      (cons first-37340
+                            (dobody-37253
+                              (cdr body-37336)
+                              r-37337
+                              w-37338
+                              mod-37339)))))))
+             (dobody-37253
+               body-37161
+               r-37162
+               w-37163
+               mod-37165)))))
+     (expand-top-sequence-4378
+       (lambda (body-21521
+                r-21522
+                w-21523
+                s-21524
+                m-21525
+                esew-21526
+                mod-21527)
+         (let ((r-21528
+                 (cons '("placeholder" placeholder) r-21522)))
+           (let ((ribcage-21529 (vector 'ribcage '() '() '())))
+             (let ((w-21530
+                     (cons (car w-21523)
+                           (cons ribcage-21529 (cdr w-21523)))))
                (letrec*
-                 ((record-definition!-21428
-                    (lambda (id-24805 var-24806)
-                      (let ((mod-24807
+                 ((record-definition!-21531
+                    (lambda (id-24931 var-24932)
+                      (let ((mod-24933
                               (cons 'hygiene (module-name (current-module)))))
-                        (let ((label-24813
-                                (cons (vector-ref id-24805 3)
-                                      (if (if (vector? var-24806)
-                                            (if (= (vector-length var-24806) 4)
-                                              (eq? (vector-ref var-24806 0)
+                        (let ((label-24939
+                                (cons (vector-ref id-24931 3)
+                                      (if (if (vector? var-24932)
+                                            (if (= (vector-length var-24932) 4)
+                                              (eq? (vector-ref var-24932 0)
                                                    'syntax-object)
                                               #f)
                                             #f)
-                                        (let ((expression-24875
-                                                (vector-ref var-24806 1))
-                                              (wrap-24876
-                                                (let ((w2-24886
+                                        (let ((expression-25001
+                                                (vector-ref var-24932 1))
+                                              (wrap-25002
+                                                (let ((w2-25012
                                                         (vector-ref
-                                                          var-24806
+                                                          var-24932
                                                           2)))
-                                                  (cons (let ((m2-24893
-                                                                (car 
w2-24886)))
-                                                          (if (null? m2-24893)
+                                                  (cons (let ((m2-25019
+                                                                (car 
w2-25012)))
+                                                          (if (null? m2-25019)
                                                             '(top)
                                                             (append
                                                               '(top)
-                                                              m2-24893)))
-                                                        (let ((m2-24902
-                                                                (cdr 
w2-24886)))
-                                                          (if (null? m2-24902)
+                                                              m2-25019)))
+                                                        (let ((m2-25028
+                                                                (cdr 
w2-25012)))
+                                                          (if (null? m2-25028)
                                                             '()
                                                             (append
                                                               '()
-                                                              m2-24902))))))
-                                              (module-24877
-                                                (vector-ref var-24806 3)))
+                                                              m2-25028))))))
+                                              (module-25003
+                                                (vector-ref var-24932 3)))
                                           (vector
                                             'syntax-object
-                                            expression-24875
-                                            wrap-24876
-                                            module-24877))
-                                        (if (null? var-24806)
-                                          var-24806
+                                            expression-25001
+                                            wrap-25002
+                                            module-25003))
+                                        (if (null? var-24932)
+                                          var-24932
                                           (vector
                                             'syntax-object
-                                            var-24806
+                                            var-24932
                                             '((top))
-                                            mod-24807))))))
+                                            mod-24933))))))
                           (begin
-                            (let ((update-24816
-                                    (cons (vector-ref id-24805 1)
-                                          (vector-ref ribcage-21426 1))))
-                              (vector-set! ribcage-21426 1 update-24816))
-                            (let ((update-24831
-                                    (cons (car (vector-ref id-24805 2))
-                                          (vector-ref ribcage-21426 2))))
-                              (vector-set! ribcage-21426 2 update-24831))
-                            (let ((update-24846
-                                    (cons label-24813
-                                          (vector-ref ribcage-21426 3))))
-                              (vector-set! ribcage-21426 3 update-24846)))))))
-                  (parse-21431
-                    (lambda (body-21626
-                             r-21627
-                             w-21628
-                             s-21629
-                             m-21630
-                             esew-21631
-                             mod-21632)
+                            (let ((update-24942
+                                    (cons (vector-ref id-24931 1)
+                                          (vector-ref ribcage-21529 1))))
+                              (vector-set! ribcage-21529 1 update-24942))
+                            (let ((update-24957
+                                    (cons (car (vector-ref id-24931 2))
+                                          (vector-ref ribcage-21529 2))))
+                              (vector-set! ribcage-21529 2 update-24957))
+                            (let ((update-24972
+                                    (cons label-24939
+                                          (vector-ref ribcage-21529 3))))
+                              (vector-set! ribcage-21529 3 update-24972)))))))
+                  (parse-21534
+                    (lambda (body-21729
+                             r-21730
+                             w-21731
+                             s-21732
+                             m-21733
+                             esew-21734
+                             mod-21735)
                       (letrec*
-                        ((lp-21633
-                           (lambda (body-21716 exps-21717)
-                             (if (null? body-21716)
-                               exps-21717
-                               (lp-21633
-                                 (cdr body-21716)
+                        ((lp-21736
+                           (lambda (body-21819 exps-21820)
+                             (if (null? body-21819)
+                               exps-21820
+                               (lp-21736
+                                 (cdr body-21819)
                                  (append
-                                   (parse1-21432
-                                     (car body-21716)
-                                     r-21627
-                                     w-21628
-                                     s-21629
-                                     m-21630
-                                     esew-21631
-                                     mod-21632)
-                                   exps-21717))))))
-                        (lp-21633 body-21626 '()))))
-                  (parse1-21432
-                    (lambda (x-21787
-                             r-21788
-                             w-21789
-                             s-21790
-                             m-21791
-                             esew-21792
-                             mod-21793)
+                                   (parse1-21535
+                                     (car body-21819)
+                                     r-21730
+                                     w-21731
+                                     s-21732
+                                     m-21733
+                                     esew-21734
+                                     mod-21735)
+                                   exps-21820))))))
+                        (lp-21736 body-21729 '()))))
+                  (parse1-21535
+                    (lambda (x-21890
+                             r-21891
+                             w-21892
+                             s-21893
+                             m-21894
+                             esew-21895
+                             mod-21896)
                       (call-with-values
                         (lambda ()
-                          (syntax-type-4585
-                            x-21787
-                            r-21788
-                            w-21789
-                            (source-annotation-4544 x-21787)
-                            ribcage-21426
-                            mod-21793
+                          (syntax-type-4381
+                            x-21890
+                            r-21891
+                            w-21892
+                            (source-annotation-4340 x-21890)
+                            ribcage-21529
+                            mod-21896
                             #f))
-                        (lambda (type-21979
-                                 value-21980
-                                 form-21981
-                                 e-21982
-                                 w-21983
-                                 s-21984
-                                 mod-21985)
-                          (if (eqv? type-21979 'define-form)
-                            (let ((id-21989
-                                    (if (if (null? (car w-21983))
-                                          (null? (cdr w-21983))
+                        (lambda (type-22082
+                                 value-22083
+                                 form-22084
+                                 e-22085
+                                 w-22086
+                                 s-22087
+                                 mod-22088)
+                          (if (eqv? type-22082 'define-form)
+                            (let ((id-22096
+                                    (if (if (null? (car w-22086))
+                                          (null? (cdr w-22086))
                                           #f)
-                                      value-21980
-                                      (if (if (vector? value-21980)
-                                            (if (= (vector-length value-21980)
+                                      value-22083
+                                      (if (if (vector? value-22083)
+                                            (if (= (vector-length value-22083)
                                                    4)
-                                              (eq? (vector-ref value-21980 0)
+                                              (eq? (vector-ref value-22083 0)
                                                    'syntax-object)
                                               #f)
                                             #f)
-                                        (let ((expression-22039
-                                                (vector-ref value-21980 1))
-                                              (wrap-22040
-                                                (let ((w2-22050
+                                        (let ((expression-22146
+                                                (vector-ref value-22083 1))
+                                              (wrap-22147
+                                                (let ((w2-22157
                                                         (vector-ref
-                                                          value-21980
+                                                          value-22083
                                                           2)))
-                                                  (let ((m1-22051
-                                                          (car w-21983))
-                                                        (s1-22052
-                                                          (cdr w-21983)))
-                                                    (if (null? m1-22051)
-                                                      (if (null? s1-22052)
-                                                        w2-22050
-                                                        (cons (car w2-22050)
-                                                              (let ((m2-22069
-                                                                      (cdr 
w2-22050)))
-                                                                (if (null? 
m2-22069)
-                                                                  s1-22052
+                                                  (let ((m1-22158
+                                                          (car w-22086))
+                                                        (s1-22159
+                                                          (cdr w-22086)))
+                                                    (if (null? m1-22158)
+                                                      (if (null? s1-22159)
+                                                        w2-22157
+                                                        (cons (car w2-22157)
+                                                              (let ((m2-22176
+                                                                      (cdr 
w2-22157)))
+                                                                (if (null? 
m2-22176)
+                                                                  s1-22159
                                                                   (append
-                                                                    s1-22052
-                                                                    
m2-22069)))))
-                                                      (cons (let ((m2-22077
-                                                                    (car 
w2-22050)))
-                                                              (if (null? 
m2-22077)
-                                                                m1-22051
+                                                                    s1-22159
+                                                                    
m2-22176)))))
+                                                      (cons (let ((m2-22184
+                                                                    (car 
w2-22157)))
+                                                              (if (null? 
m2-22184)
+                                                                m1-22158
                                                                 (append
-                                                                  m1-22051
-                                                                  m2-22077)))
-                                                            (let ((m2-22085
-                                                                    (cdr 
w2-22050)))
-                                                              (if (null? 
m2-22085)
-                                                                s1-22052
+                                                                  m1-22158
+                                                                  m2-22184)))
+                                                            (let ((m2-22192
+                                                                    (cdr 
w2-22157)))
+                                                              (if (null? 
m2-22192)
+                                                                s1-22159
                                                                 (append
-                                                                  s1-22052
-                                                                  
m2-22085))))))))
-                                              (module-22041
-                                                (vector-ref value-21980 3)))
+                                                                  s1-22159
+                                                                  
m2-22192))))))))
+                                              (module-22148
+                                                (vector-ref value-22083 3)))
                                           (vector
                                             'syntax-object
-                                            expression-22039
-                                            wrap-22040
-                                            module-22041))
-                                        (if (null? value-21980)
-                                          value-21980
+                                            expression-22146
+                                            wrap-22147
+                                            module-22148))
+                                        (if (null? value-22083)
+                                          value-22083
                                           (vector
                                             'syntax-object
-                                            value-21980
-                                            w-21983
-                                            mod-21985))))))
+                                            value-22083
+                                            w-22086
+                                            mod-22088))))))
                               (begin
                                 (string-append
                                   "l-"
-                                  (session-id-4511)
+                                  (session-id-4307)
                                   (symbol->string (gensym "-")))
-                                (let ((var-21991
+                                (let ((var-22098
                                         (if (not (equal?
                                                    (car (vector-ref
-                                                          id-21989
+                                                          id-22096
                                                           2))
                                                    '(top)))
                                           (symbol-append
-                                            (vector-ref id-21989 1)
+                                            (vector-ref id-22096 1)
                                             '-
                                             (string->symbol
                                               (number->string
-                                                (hash (syntax->datum x-21787)
+                                                (hash (syntax->datum x-21890)
                                                       most-positive-fixnum)
                                                 16)))
-                                          (vector-ref id-21989 1))))
+                                          (vector-ref id-22096 1))))
                                   (begin
-                                    (record-definition!-21428
-                                      id-21989
-                                      var-21991)
-                                    (list (if (eq? m-21791 'c&e)
-                                            (let ((x-22211
-                                                    
(build-global-definition-4525
-                                                      s-21984
-                                                      var-21991
-                                                      (expand-4586
-                                                        e-21982
-                                                        r-21788
-                                                        w-21983
-                                                        mod-21985))))
+                                    (record-definition!-21531
+                                      id-22096
+                                      var-22098)
+                                    (list (if (eq? m-21894 'c&e)
+                                            (let ((x-22318
+                                                    
(build-global-definition-4321
+                                                      s-22087
+                                                      var-22098
+                                                      (expand-4382
+                                                        e-22085
+                                                        r-21891
+                                                        w-22086
+                                                        mod-22088))))
                                               (begin
-                                                (top-level-eval-hook-4509
-                                                  x-22211
-                                                  mod-21985)
-                                                (lambda () x-22211)))
+                                                (top-level-eval-hook-4305
+                                                  x-22318
+                                                  mod-22088)
+                                                (lambda () x-22318)))
                                             (lambda ()
-                                              (build-global-definition-4525
-                                                s-21984
-                                                var-21991
-                                                (expand-4586
-                                                  e-21982
-                                                  r-21788
-                                                  w-21983
-                                                  mod-21985)))))))))
-                            (if (if (eqv? type-21979 'define-syntax-form)
+                                              (build-global-definition-4321
+                                                s-22087
+                                                var-22098
+                                                (expand-4382
+                                                  e-22085
+                                                  r-21891
+                                                  w-22086
+                                                  mod-22088)))))))))
+                            (if (if (eqv? type-22082 'define-syntax-form)
                                   #t
-                                  (eqv? type-21979
+                                  (eqv? type-22082
                                         'define-syntax-parameter-form))
-                              (let ((id-22705
-                                      (if (if (null? (car w-21983))
-                                            (null? (cdr w-21983))
+                              (let ((id-22815
+                                      (if (if (null? (car w-22086))
+                                            (null? (cdr w-22086))
                                             #f)
-                                        value-21980
-                                        (if (if (vector? value-21980)
+                                        value-22083
+                                        (if (if (vector? value-22083)
                                               (if (= (vector-length
-                                                       value-21980)
+                                                       value-22083)
                                                      4)
-                                                (eq? (vector-ref value-21980 0)
+                                                (eq? (vector-ref value-22083 0)
                                                      'syntax-object)
                                                 #f)
                                               #f)
-                                          (let ((expression-22755
-                                                  (vector-ref value-21980 1))
-                                                (wrap-22756
-                                                  (let ((w2-22766
+                                          (let ((expression-22865
+                                                  (vector-ref value-22083 1))
+                                                (wrap-22866
+                                                  (let ((w2-22876
                                                           (vector-ref
-                                                            value-21980
+                                                            value-22083
                                                             2)))
-                                                    (let ((m1-22767
-                                                            (car w-21983))
-                                                          (s1-22768
-                                                            (cdr w-21983)))
-                                                      (if (null? m1-22767)
-                                                        (if (null? s1-22768)
-                                                          w2-22766
-                                                          (cons (car w2-22766)
-                                                                (let ((m2-22785
-                                                                        (cdr 
w2-22766)))
-                                                                  (if (null? 
m2-22785)
-                                                                    s1-22768
+                                                    (let ((m1-22877
+                                                            (car w-22086))
+                                                          (s1-22878
+                                                            (cdr w-22086)))
+                                                      (if (null? m1-22877)
+                                                        (if (null? s1-22878)
+                                                          w2-22876
+                                                          (cons (car w2-22876)
+                                                                (let ((m2-22895
+                                                                        (cdr 
w2-22876)))
+                                                                  (if (null? 
m2-22895)
+                                                                    s1-22878
                                                                     (append
-                                                                      s1-22768
-                                                                      
m2-22785)))))
-                                                        (cons (let ((m2-22793
-                                                                      (car 
w2-22766)))
-                                                                (if (null? 
m2-22793)
-                                                                  m1-22767
+                                                                      s1-22878
+                                                                      
m2-22895)))))
+                                                        (cons (let ((m2-22903
+                                                                      (car 
w2-22876)))
+                                                                (if (null? 
m2-22903)
+                                                                  m1-22877
                                                                   (append
-                                                                    m1-22767
-                                                                    m2-22793)))
-                                                              (let ((m2-22801
-                                                                      (cdr 
w2-22766)))
-                                                                (if (null? 
m2-22801)
-                                                                  s1-22768
+                                                                    m1-22877
+                                                                    m2-22903)))
+                                                              (let ((m2-22911
+                                                                      (cdr 
w2-22876)))
+                                                                (if (null? 
m2-22911)
+                                                                  s1-22878
                                                                   (append
-                                                                    s1-22768
-                                                                    
m2-22801))))))))
-                                                (module-22757
-                                                  (vector-ref value-21980 3)))
+                                                                    s1-22878
+                                                                    
m2-22911))))))))
+                                                (module-22867
+                                                  (vector-ref value-22083 3)))
                                             (vector
                                               'syntax-object
-                                              expression-22755
-                                              wrap-22756
-                                              module-22757))
-                                          (if (null? value-21980)
-                                            value-21980
+                                              expression-22865
+                                              wrap-22866
+                                              module-22867))
+                                          (if (null? value-22083)
+                                            value-22083
                                             (vector
                                               'syntax-object
-                                              value-21980
-                                              w-21983
-                                              mod-21985))))))
+                                              value-22083
+                                              w-22086
+                                              mod-22088))))))
                                 (begin
                                   (string-append
                                     "l-"
-                                    (session-id-4511)
+                                    (session-id-4307)
                                     (symbol->string (gensym "-")))
-                                  (let ((var-22707
+                                  (let ((var-22817
                                           (if (not (equal?
                                                      (car (vector-ref
-                                                            id-22705
+                                                            id-22815
                                                             2))
                                                      '(top)))
                                             (symbol-append
-                                              (vector-ref id-22705 1)
+                                              (vector-ref id-22815 1)
                                               '-
                                               (string->symbol
                                                 (number->string
-                                                  (hash (syntax->datum x-21787)
+                                                  (hash (syntax->datum x-21890)
                                                         most-positive-fixnum)
                                                   16)))
-                                            (vector-ref id-22705 1))))
+                                            (vector-ref id-22815 1))))
                                     (begin
-                                      (record-definition!-21428
-                                        id-22705
-                                        var-22707)
-                                      (if (eqv? m-21791 'c)
-                                        (if (memq 'compile esew-21792)
-                                          (let ((e-22930
-                                                  (expand-install-global-4583
-                                                    var-22707
-                                                    type-21979
-                                                    (expand-4586
-                                                      e-21982
-                                                      r-21788
-                                                      w-21983
-                                                      mod-21985))))
+                                      (record-definition!-21531
+                                        id-22815
+                                        var-22817)
+                                      (if (eqv? m-21894 'c)
+                                        (if (memq 'compile esew-21895)
+                                          (let ((e-23044
+                                                  (expand-install-global-4379
+                                                    var-22817
+                                                    type-22082
+                                                    (expand-4382
+                                                      e-22085
+                                                      r-21891
+                                                      w-22086
+                                                      mod-22088))))
                                             (begin
-                                              (top-level-eval-hook-4509
-                                                e-22930
-                                                mod-21985)
-                                              (if (memq 'load esew-21792)
-                                                (list (lambda () e-22930))
+                                              (top-level-eval-hook-4305
+                                                e-23044
+                                                mod-22088)
+                                              (if (memq 'load esew-21895)
+                                                (list (lambda () e-23044))
                                                 '())))
-                                          (if (memq 'load esew-21792)
+                                          (if (memq 'load esew-21895)
                                             (list (lambda ()
-                                                    (expand-install-global-4583
-                                                      var-22707
-                                                      type-21979
-                                                      (expand-4586
-                                                        e-21982
-                                                        r-21788
-                                                        w-21983
-                                                        mod-21985))))
+                                                    (expand-install-global-4379
+                                                      var-22817
+                                                      type-22082
+                                                      (expand-4382
+                                                        e-22085
+                                                        r-21891
+                                                        w-22086
+                                                        mod-22088))))
                                             '()))
-                                        (if (eqv? m-21791 'c&e)
-                                          (let ((e-23433
-                                                  (expand-install-global-4583
-                                                    var-22707
-                                                    type-21979
-                                                    (expand-4586
-                                                      e-21982
-                                                      r-21788
-                                                      w-21983
-                                                      mod-21985))))
+                                        (if (eqv? m-21894 'c&e)
+                                          (let ((e-23550
+                                                  (expand-install-global-4379
+                                                    var-22817
+                                                    type-22082
+                                                    (expand-4382
+                                                      e-22085
+                                                      r-21891
+                                                      w-22086
+                                                      mod-22088))))
                                             (begin
-                                              (top-level-eval-hook-4509
-                                                e-23433
-                                                mod-21985)
-                                              (list (lambda () e-23433))))
+                                              (top-level-eval-hook-4305
+                                                e-23550
+                                                mod-22088)
+                                              (list (lambda () e-23550))))
                                           (begin
-                                            (if (memq 'eval esew-21792)
-                                              (top-level-eval-hook-4509
-                                                (expand-install-global-4583
-                                                  var-22707
-                                                  type-21979
-                                                  (expand-4586
-                                                    e-21982
-                                                    r-21788
-                                                    w-21983
-                                                    mod-21985))
-                                                mod-21985))
+                                            (if (memq 'eval esew-21895)
+                                              (top-level-eval-hook-4305
+                                                (expand-install-global-4379
+                                                  var-22817
+                                                  type-22082
+                                                  (expand-4382
+                                                    e-22085
+                                                    r-21891
+                                                    w-22086
+                                                    mod-22088))
+                                                mod-22088))
                                             '())))))))
-                              (if (eqv? type-21979 'begin-form)
-                                (let ((tmp-24043
+                              (if (eqv? type-22082 'begin-form)
+                                (let ((tmp-24163
                                         ($sc-dispatch
-                                          e-21982
+                                          e-22085
                                           '(_ . each-any))))
-                                  (if tmp-24043
+                                  (if tmp-24163
                                     (@apply
-                                      (lambda (e1-24047)
-                                        (parse-21431
-                                          e1-24047
-                                          r-21788
-                                          w-21983
-                                          s-21984
-                                          m-21791
-                                          esew-21792
-                                          mod-21985))
-                                      tmp-24043)
+                                      (lambda (e1-24167)
+                                        (parse-21534
+                                          e1-24167
+                                          r-21891
+                                          w-22086
+                                          s-22087
+                                          m-21894
+                                          esew-21895
+                                          mod-22088))
+                                      tmp-24163)
                                     (syntax-violation
                                       #f
                                       "source expression failed to match any 
pattern"
-                                      e-21982)))
-                                (if (eqv? type-21979 'local-syntax-form)
-                                  (expand-local-syntax-4591
-                                    value-21980
-                                    e-21982
-                                    r-21788
-                                    w-21983
-                                    s-21984
-                                    mod-21985
-                                    (lambda (forms-24090
-                                             r-24091
-                                             w-24092
-                                             s-24093
-                                             mod-24094)
-                                      (parse-21431
-                                        forms-24090
-                                        r-24091
-                                        w-24092
-                                        s-24093
-                                        m-21791
-                                        esew-21792
-                                        mod-24094)))
-                                  (if (eqv? type-21979 'eval-when-form)
-                                    (let ((tmp-24130
+                                      e-22085)))
+                                (if (eqv? type-22082 'local-syntax-form)
+                                  (expand-local-syntax-4387
+                                    value-22083
+                                    e-22085
+                                    r-21891
+                                    w-22086
+                                    s-22087
+                                    mod-22088
+                                    (lambda (forms-24213
+                                             r-24214
+                                             w-24215
+                                             s-24216
+                                             mod-24217)
+                                      (parse-21534
+                                        forms-24213
+                                        r-24214
+                                        w-24215
+                                        s-24216
+                                        m-21894
+                                        esew-21895
+                                        mod-24217)))
+                                  (if (eqv? type-22082 'eval-when-form)
+                                    (let ((tmp-24256
                                             ($sc-dispatch
-                                              e-21982
+                                              e-22085
                                               '(_ each-any any . each-any))))
-                                      (if tmp-24130
+                                      (if tmp-24256
                                         (@apply
-                                          (lambda (x-24134 e1-24135 e2-24136)
-                                            (let ((when-list-24137
-                                                    (parse-when-list-4584
-                                                      e-21982
-                                                      x-24134))
-                                                  (body-24138
-                                                    (cons e1-24135 e2-24136)))
+                                          (lambda (x-24260 e1-24261 e2-24262)
+                                            (let ((when-list-24263
+                                                    (parse-when-list-4380
+                                                      e-22085
+                                                      x-24260))
+                                                  (body-24264
+                                                    (cons e1-24261 e2-24262)))
                                               (letrec*
-                                                ((recurse-24139
-                                                   (lambda (m-24725 esew-24726)
-                                                     (parse-21431
-                                                       body-24138
-                                                       r-21788
-                                                       w-21983
-                                                       s-21984
-                                                       m-24725
-                                                       esew-24726
-                                                       mod-21985))))
-                                                (if (eq? m-21791 'e)
+                                                ((recurse-24265
+                                                   (lambda (m-24851 esew-24852)
+                                                     (parse-21534
+                                                       body-24264
+                                                       r-21891
+                                                       w-22086
+                                                       s-22087
+                                                       m-24851
+                                                       esew-24852
+                                                       mod-22088))))
+                                                (if (eq? m-21894 'e)
                                                   (if (memq 'eval
-                                                            when-list-24137)
-                                                    (recurse-24139
+                                                            when-list-24263)
+                                                    (recurse-24265
                                                       (if (memq 'expand
-                                                                
when-list-24137)
+                                                                
when-list-24263)
                                                         'c&e
                                                         'e)
                                                       '(eval))
                                                     (begin
                                                       (if (memq 'expand
-                                                                
when-list-24137)
-                                                        (let ((x-24246
-                                                                
(expand-top-sequence-4582
-                                                                  body-24138
-                                                                  r-21788
-                                                                  w-21983
-                                                                  s-21984
+                                                                
when-list-24263)
+                                                        (let ((x-24372
+                                                                
(expand-top-sequence-4378
+                                                                  body-24264
+                                                                  r-21891
+                                                                  w-22086
+                                                                  s-22087
                                                                   'e
                                                                   '(eval)
-                                                                  mod-21985)))
+                                                                  mod-22088)))
                                                           (primitive-eval
-                                                            x-24246)))
+                                                            x-24372)))
                                                       '()))
                                                   (if (memq 'load
-                                                            when-list-24137)
-                                                    (if (let ((t-24274
+                                                            when-list-24263)
+                                                    (if (let ((t-24400
                                                                 (memq 'compile
-                                                                      
when-list-24137)))
-                                                          (if t-24274
-                                                            t-24274
-                                                            (let ((t-24327
+                                                                      
when-list-24263)))
+                                                          (if t-24400
+                                                            t-24400
+                                                            (let ((t-24453
                                                                     (memq 
'expand
-                                                                          
when-list-24137)))
-                                                              (if t-24327
-                                                                t-24327
-                                                                (if (eq? 
m-21791
+                                                                          
when-list-24263)))
+                                                              (if t-24453
+                                                                t-24453
+                                                                (if (eq? 
m-21894
                                                                          'c&e)
                                                                   (memq 'eval
-                                                                        
when-list-24137)
+                                                                        
when-list-24263)
                                                                   #f)))))
-                                                      (recurse-24139
+                                                      (recurse-24265
                                                         'c&e
                                                         '(compile load))
-                                                      (if (if (eq? m-21791 'c)
+                                                      (if (if (eq? m-21894 'c)
                                                             #t
-                                                            (eq? m-21791 'c&e))
-                                                        (recurse-24139
+                                                            (eq? m-21894 'c&e))
+                                                        (recurse-24265
                                                           'c
                                                           '(load))
                                                         '()))
-                                                    (if (let ((t-24536
+                                                    (if (let ((t-24662
                                                                 (memq 'compile
-                                                                      
when-list-24137)))
-                                                          (if t-24536
-                                                            t-24536
-                                                            (let ((t-24589
+                                                                      
when-list-24263)))
+                                                          (if t-24662
+                                                            t-24662
+                                                            (let ((t-24715
                                                                     (memq 
'expand
-                                                                          
when-list-24137)))
-                                                              (if t-24589
-                                                                t-24589
-                                                                (if (eq? 
m-21791
+                                                                          
when-list-24263)))
+                                                              (if t-24715
+                                                                t-24715
+                                                                (if (eq? 
m-21894
                                                                          'c&e)
                                                                   (memq 'eval
-                                                                        
when-list-24137)
+                                                                        
when-list-24263)
                                                                   #f)))))
                                                       (begin
-                                                        (let ((x-24723
-                                                                
(expand-top-sequence-4582
-                                                                  body-24138
-                                                                  r-21788
-                                                                  w-21983
-                                                                  s-21984
+                                                        (let ((x-24849
+                                                                
(expand-top-sequence-4378
+                                                                  body-24264
+                                                                  r-21891
+                                                                  w-22086
+                                                                  s-22087
                                                                   'e
                                                                   '(eval)
-                                                                  mod-21985)))
+                                                                  mod-22088)))
                                                           (primitive-eval
-                                                            x-24723))
+                                                            x-24849))
                                                         '())
                                                       '()))))))
-                                          tmp-24130)
+                                          tmp-24256)
                                         (syntax-violation
                                           #f
                                           "source expression failed to match 
any pattern"
-                                          e-21982)))
-                                    (list (if (eq? m-21791 'c&e)
-                                            (let ((x-24796
-                                                    (expand-expr-4587
-                                                      type-21979
-                                                      value-21980
-                                                      form-21981
-                                                      e-21982
-                                                      r-21788
-                                                      w-21983
-                                                      s-21984
-                                                      mod-21985)))
+                                          e-22085)))
+                                    (list (if (eq? m-21894 'c&e)
+                                            (let ((x-24922
+                                                    (expand-expr-4383
+                                                      type-22082
+                                                      value-22083
+                                                      form-22084
+                                                      e-22085
+                                                      r-21891
+                                                      w-22086
+                                                      s-22087
+                                                      mod-22088)))
                                               (begin
-                                                (primitive-eval x-24796)
-                                                (lambda () x-24796)))
+                                                (primitive-eval x-24922)
+                                                (lambda () x-24922)))
                                             (lambda ()
-                                              (expand-expr-4587
-                                                type-21979
-                                                value-21980
-                                                form-21981
-                                                e-21982
-                                                r-21788
-                                                w-21983
-                                                s-21984
-                                                mod-21985))))))))))))))
-                 (let ((exps-21433
-                         (map (lambda (x-21556) (x-21556))
+                                              (expand-expr-4383
+                                                type-22082
+                                                value-22083
+                                                form-22084
+                                                e-22085
+                                                r-21891
+                                                w-22086
+                                                s-22087
+                                                mod-22088))))))))))))))
+                 (let ((exps-21536
+                         (map (lambda (x-21659) (x-21659))
                               (reverse
-                                (parse-21431
-                                  body-21418
-                                  r-21425
-                                  w-21427
-                                  s-21421
-                                  m-21422
-                                  esew-21423
-                                  mod-21424)))))
-                   (if (null? exps-21433)
+                                (parse-21534
+                                  body-21521
+                                  r-21528
+                                  w-21530
+                                  s-21524
+                                  m-21525
+                                  esew-21526
+                                  mod-21527)))))
+                   (if (null? exps-21536)
                      (make-struct/no-tail
                        (vector-ref %expanded-vtables 0)
-                       s-21421)
-                     (build-sequence-4532 s-21421 exps-21433)))))))))
-     (expand-install-global-4583
-       (lambda (name-24924 type-24925 e-24926)
-         (let ((exp-24932
-                 (let ((args-24943
-                         (if (eq? type-24925 'define-syntax-parameter-form)
+                       s-21524)
+                     (build-sequence-4328 s-21524 exps-21536)))))))))
+     (expand-install-global-4379
+       (lambda (name-25050 type-25051 e-25052)
+         (let ((exp-25058
+                 (let ((args-25069
+                         (if (eq? type-25051 'define-syntax-parameter-form)
                            (list (make-struct/no-tail
                                    (vector-ref %expanded-vtables 1)
                                    #f
-                                   name-24924)
+                                   name-25050)
                                  (make-struct/no-tail
                                    (vector-ref %expanded-vtables 1)
                                    #f
                                    'syntax-parameter)
-                                 (let ((args-24966 (list e-24926)))
+                                 (let ((args-25092 (list e-25052)))
                                    (make-struct/no-tail
                                      (vector-ref %expanded-vtables 12)
                                      #f
                                      'list
-                                     args-24966)))
+                                     args-25092)))
                            (list (make-struct/no-tail
                                    (vector-ref %expanded-vtables 1)
                                    #f
-                                   name-24924)
+                                   name-25050)
                                  (make-struct/no-tail
                                    (vector-ref %expanded-vtables 1)
                                    #f
                                    'macro)
-                                 e-24926))))
+                                 e-25052))))
                    (make-struct/no-tail
                      (vector-ref %expanded-vtables 12)
                      #f
                      'make-syntax-transformer
-                     args-24943))))
+                     args-25069))))
            (begin
-             (if (if (struct? exp-24932)
-                   (eq? (struct-vtable exp-24932)
+             (if (if (struct? exp-25058)
+                   (eq? (struct-vtable exp-25058)
                         (vector-ref %expanded-vtables 14))
                    #f)
-               (let ((meta-24993 (struct-ref exp-24932 1)))
-                 (if (not (assq 'name meta-24993))
-                   (let ((v-25000
-                           (cons (cons 'name name-24924) meta-24993)))
-                     (struct-set! exp-24932 1 v-25000)))))
+               (let ((meta-25119 (struct-ref exp-25058 1)))
+                 (if (not (assq 'name meta-25119))
+                   (let ((v-25126
+                           (cons (cons 'name name-25050) meta-25119)))
+                     (struct-set! exp-25058 1 v-25126)))))
              (make-struct/no-tail
                (vector-ref %expanded-vtables 9)
                #f
-               name-24924
-               exp-24932)))))
-     (parse-when-list-4584
-       (lambda (e-25011 when-list-25012)
-         (let ((result-25013 (strip-4599 when-list-25012 '(()))))
+               name-25050
+               exp-25058)))))
+     (parse-when-list-4380
+       (lambda (e-25137 when-list-25138)
+         (let ((result-25139 (strip-4395 when-list-25138 '(()))))
            (letrec*
-             ((lp-25014
-                (lambda (l-25080)
-                  (if (null? l-25080)
-                    result-25013
-                    (if (let ((t-25082 (car l-25080)))
-                          (if (eq? t-25082 'compile)
+             ((lp-25140
+                (lambda (l-25206)
+                  (if (null? l-25206)
+                    result-25139
+                    (if (let ((t-25208 (car l-25206)))
+                          (if (eq? t-25208 'compile)
                             #t
-                            (if (eq? t-25082 'load)
+                            (if (eq? t-25208 'load)
                               #t
-                              (if (eq? t-25082 'eval)
+                              (if (eq? t-25208 'eval)
                                 #t
-                                (eq? t-25082 'expand)))))
-                      (lp-25014 (cdr l-25080))
+                                (eq? t-25208 'expand)))))
+                      (lp-25140 (cdr l-25206))
                       (syntax-violation
                         'eval-when
                         "invalid situation"
-                        e-25011
-                        (car l-25080)))))))
-             (lp-25014 result-25013)))))
-     (syntax-type-4585
-       (lambda (e-25084
-                r-25085
-                w-25086
-                s-25087
-                rib-25088
-                mod-25089
-                for-car?-25090)
-         (if (symbol? e-25084)
+                        e-25137
+                        (car l-25206)))))))
+             (lp-25140 result-25139)))))
+     (syntax-type-4381
+       (lambda (e-25210
+                r-25211
+                w-25212
+                s-25213
+                rib-25214
+                mod-25215
+                for-car?-25216)
+         (if (symbol? e-25210)
            (call-with-values
              (lambda ()
-               (resolve-identifier-4571
-                 e-25084
-                 w-25086
-                 r-25085
-                 mod-25089
+               (resolve-identifier-4367
+                 e-25210
+                 w-25212
+                 r-25211
+                 mod-25215
                  #t))
-             (lambda (type-25093 value-25094 mod*-25095)
-               (if (eqv? type-25093 'macro)
-                 (if for-car?-25090
+             (lambda (type-25219 value-25220 mod*-25221)
+               (if (eqv? type-25219 'macro)
+                 (if for-car?-25216
                    (values
-                     type-25093
-                     value-25094
-                     e-25084
-                     e-25084
-                     w-25086
-                     s-25087
-                     mod-25089)
-                   (syntax-type-4585
-                     (expand-macro-4589
-                       value-25094
-                       e-25084
-                       r-25085
-                       w-25086
-                       s-25087
-                       rib-25088
-                       mod-25089)
-                     r-25085
+                     type-25219
+                     value-25220
+                     e-25210
+                     e-25210
+                     w-25212
+                     s-25213
+                     mod-25215)
+                   (syntax-type-4381
+                     (expand-macro-4385
+                       value-25220
+                       e-25210
+                       r-25211
+                       w-25212
+                       s-25213
+                       rib-25214
+                       mod-25215)
+                     r-25211
                      '(())
-                     s-25087
-                     rib-25088
-                     mod-25089
+                     s-25213
+                     rib-25214
+                     mod-25215
                      #f))
-                 (if (eqv? type-25093 'global)
+                 (if (eqv? type-25219 'global)
                    (values
-                     type-25093
-                     value-25094
-                     e-25084
-                     value-25094
-                     w-25086
-                     s-25087
-                     mod*-25095)
+                     type-25219
+                     value-25220
+                     e-25210
+                     value-25220
+                     w-25212
+                     s-25213
+                     mod*-25221)
                    (values
-                     type-25093
-                     value-25094
-                     e-25084
-                     e-25084
-                     w-25086
-                     s-25087
-                     mod-25089)))))
-           (if (pair? e-25084)
-             (let ((first-25104 (car e-25084)))
+                     type-25219
+                     value-25220
+                     e-25210
+                     e-25210
+                     w-25212
+                     s-25213
+                     mod-25215)))))
+           (if (pair? e-25210)
+             (let ((first-25237 (car e-25210)))
                (call-with-values
                  (lambda ()
-                   (syntax-type-4585
-                     first-25104
-                     r-25085
-                     w-25086
-                     s-25087
-                     rib-25088
-                     mod-25089
+                   (syntax-type-4381
+                     first-25237
+                     r-25211
+                     w-25212
+                     s-25213
+                     rib-25214
+                     mod-25215
                      #t))
-                 (lambda (ftype-25106
-                          fval-25107
-                          fform-25108
-                          fe-25109
-                          fw-25110
-                          fs-25111
-                          fmod-25112)
-                   (if (eqv? ftype-25106 'lexical)
+                 (lambda (ftype-25239
+                          fval-25240
+                          fform-25241
+                          fe-25242
+                          fw-25243
+                          fs-25244
+                          fmod-25245)
+                   (if (eqv? ftype-25239 'lexical)
                      (values
                        'lexical-call
-                       fval-25107
-                       e-25084
-                       e-25084
-                       w-25086
-                       s-25087
-                       mod-25089)
-                     (if (eqv? ftype-25106 'global)
+                       fval-25240
+                       e-25210
+                       e-25210
+                       w-25212
+                       s-25213
+                       mod-25215)
+                     (if (eqv? ftype-25239 'global)
                        (values
                          'global-call
                          (vector
                            'syntax-object
-                           fval-25107
-                           w-25086
-                           fmod-25112)
-                         e-25084
-                         e-25084
-                         w-25086
-                         s-25087
-                         mod-25089)
-                       (if (eqv? ftype-25106 'macro)
-                         (syntax-type-4585
-                           (expand-macro-4589
-                             fval-25107
-                             e-25084
-                             r-25085
-                             w-25086
-                             s-25087
-                             rib-25088
-                             mod-25089)
-                           r-25085
+                           fval-25240
+                           w-25212
+                           fmod-25245)
+                         e-25210
+                         e-25210
+                         w-25212
+                         s-25213
+                         mod-25215)
+                       (if (eqv? ftype-25239 'macro)
+                         (syntax-type-4381
+                           (expand-macro-4385
+                             fval-25240
+                             e-25210
+                             r-25211
+                             w-25212
+                             s-25213
+                             rib-25214
+                             mod-25215)
+                           r-25211
                            '(())
-                           s-25087
-                           rib-25088
-                           mod-25089
-                           for-car?-25090)
-                         (if (eqv? ftype-25106 'module-ref)
+                           s-25213
+                           rib-25214
+                           mod-25215
+                           for-car?-25216)
+                         (if (eqv? ftype-25239 'module-ref)
                            (call-with-values
-                             (lambda () (fval-25107 e-25084 r-25085 w-25086))
-                             (lambda (e-25133
-                                      r-25134
-                                      w-25135
-                                      s-25136
-                                      mod-25137)
-                               (syntax-type-4585
-                                 e-25133
-                                 r-25134
-                                 w-25135
-                                 s-25136
-                                 rib-25088
-                                 mod-25137
-                                 for-car?-25090)))
-                           (if (eqv? ftype-25106 'core)
+                             (lambda () (fval-25240 e-25210 r-25211 w-25212))
+                             (lambda (e-25279
+                                      r-25280
+                                      w-25281
+                                      s-25282
+                                      mod-25283)
+                               (syntax-type-4381
+                                 e-25279
+                                 r-25280
+                                 w-25281
+                                 s-25282
+                                 rib-25214
+                                 mod-25283
+                                 for-car?-25216)))
+                           (if (eqv? ftype-25239 'core)
                              (values
                                'core-form
-                               fval-25107
-                               e-25084
-                               e-25084
-                               w-25086
-                               s-25087
-                               mod-25089)
-                             (if (eqv? ftype-25106 'local-syntax)
+                               fval-25240
+                               e-25210
+                               e-25210
+                               w-25212
+                               s-25213
+                               mod-25215)
+                             (if (eqv? ftype-25239 'local-syntax)
                                (values
                                  'local-syntax-form
-                                 fval-25107
-                                 e-25084
-                                 e-25084
-                                 w-25086
-                                 s-25087
-                                 mod-25089)
-                               (if (eqv? ftype-25106 'begin)
+                                 fval-25240
+                                 e-25210
+                                 e-25210
+                                 w-25212
+                                 s-25213
+                                 mod-25215)
+                               (if (eqv? ftype-25239 'begin)
                                  (values
                                    'begin-form
                                    #f
-                                   e-25084
-                                   e-25084
-                                   w-25086
-                                   s-25087
-                                   mod-25089)
-                                 (if (eqv? ftype-25106 'eval-when)
+                                   e-25210
+                                   e-25210
+                                   w-25212
+                                   s-25213
+                                   mod-25215)
+                                 (if (eqv? ftype-25239 'eval-when)
                                    (values
                                      'eval-when-form
                                      #f
-                                     e-25084
-                                     e-25084
-                                     w-25086
-                                     s-25087
-                                     mod-25089)
-                                   (if (eqv? ftype-25106 'define)
-                                     (let ((tmp-25154
+                                     e-25210
+                                     e-25210
+                                     w-25212
+                                     s-25213
+                                     mod-25215)
+                                   (if (eqv? ftype-25239 'define)
+                                     (let ((tmp-25315
                                              ($sc-dispatch
-                                               e-25084
+                                               e-25210
                                                '(_ any any))))
-                                       (if (if tmp-25154
+                                       (if (if tmp-25315
                                              (@apply
-                                               (lambda (name-25158 val-25159)
-                                                 (if (symbol? name-25158)
+                                               (lambda (name-25319 val-25320)
+                                                 (if (symbol? name-25319)
                                                    #t
-                                                   (if (if (vector? name-25158)
+                                                   (if (if (vector? name-25319)
                                                          (if (= (vector-length
-                                                                  name-25158)
+                                                                  name-25319)
                                                                 4)
                                                            (eq? (vector-ref
-                                                                  name-25158
+                                                                  name-25319
                                                                   0)
                                                                 'syntax-object)
                                                            #f)
                                                          #f)
                                                      (symbol?
                                                        (vector-ref
-                                                         name-25158
+                                                         name-25319
                                                          1))
                                                      #f)))
-                                               tmp-25154)
+                                               tmp-25315)
                                              #f)
                                          (@apply
-                                           (lambda (name-25186 val-25187)
+                                           (lambda (name-25347 val-25348)
                                              (values
                                                'define-form
-                                               name-25186
-                                               e-25084
-                                               val-25187
-                                               w-25086
-                                               s-25087
-                                               mod-25089))
-                                           tmp-25154)
-                                         (let ((tmp-25188
+                                               name-25347
+                                               e-25210
+                                               val-25348
+                                               w-25212
+                                               s-25213
+                                               mod-25215))
+                                           tmp-25315)
+                                         (let ((tmp-25349
                                                  ($sc-dispatch
-                                                   e-25084
+                                                   e-25210
                                                    '(_ (any . any)
                                                        any
                                                        .
                                                        each-any))))
-                                           (if (if tmp-25188
+                                           (if (if tmp-25349
                                                  (@apply
-                                                   (lambda (name-25192
-                                                            args-25193
-                                                            e1-25194
-                                                            e2-25195)
+                                                   (lambda (name-25353
+                                                            args-25354
+                                                            e1-25355
+                                                            e2-25356)
                                                      (if (if (symbol?
-                                                               name-25192)
+                                                               name-25353)
                                                            #t
                                                            (if (if (vector?
-                                                                     
name-25192)
+                                                                     
name-25353)
                                                                  (if (= 
(vector-length
-                                                                          
name-25192)
+                                                                          
name-25353)
                                                                         4)
                                                                    (eq? 
(vector-ref
-                                                                          
name-25192
+                                                                          
name-25353
                                                                           0)
                                                                         
'syntax-object)
                                                                    #f)
                                                                  #f)
                                                              (symbol?
                                                                (vector-ref
-                                                                 name-25192
+                                                                 name-25353
                                                                  1))
                                                              #f))
-                                                       (valid-bound-ids?-4576
-                                                         (lambda-var-list-4601
-                                                           args-25193))
+                                                       (valid-bound-ids?-4372
+                                                         (lambda-var-list-4397
+                                                           args-25354))
                                                        #f))
-                                                   tmp-25188)
+                                                   tmp-25349)
                                                  #f)
                                              (@apply
-                                               (lambda (name-25658
-                                                        args-25659
-                                                        e1-25660
-                                                        e2-25661)
+                                               (lambda (name-25819
+                                                        args-25820
+                                                        e1-25821
+                                                        e2-25822)
                                                  (values
                                                    'define-form
-                                                   (if (if (null? (car 
w-25086))
-                                                         (null? (cdr w-25086))
+                                                   (if (if (null? (car 
w-25212))
+                                                         (null? (cdr w-25212))
                                                          #f)
-                                                     name-25658
+                                                     name-25819
                                                      (if (if (vector?
-                                                               name-25658)
+                                                               name-25819)
                                                            (if (= 
(vector-length
-                                                                    name-25658)
+                                                                    name-25819)
                                                                   4)
                                                              (eq? (vector-ref
-                                                                    name-25658
+                                                                    name-25819
                                                                     0)
                                                                   
'syntax-object)
                                                              #f)
                                                            #f)
-                                                       (let ((expression-25691
+                                                       (let ((expression-25852
                                                                (vector-ref
-                                                                 name-25658
+                                                                 name-25819
                                                                  1))
-                                                             (wrap-25692
-                                                               (let ((w2-25702
+                                                             (wrap-25853
+                                                               (let ((w2-25863
                                                                        
(vector-ref
-                                                                         
name-25658
+                                                                         
name-25819
                                                                          2)))
-                                                                 (let 
((m1-25703
-                                                                         (car 
w-25086))
-                                                                       
(s1-25704
-                                                                         (cdr 
w-25086)))
-                                                                   (if (null? 
m1-25703)
-                                                                     (if 
(null? s1-25704)
-                                                                       w2-25702
-                                                                       (cons 
(car w2-25702)
-                                                                             
(let ((m2-25721
-                                                                               
      (cdr w2-25702)))
-                                                                               
(if (null? m2-25721)
-                                                                               
  s1-25704
+                                                                 (let 
((m1-25864
+                                                                         (car 
w-25212))
+                                                                       
(s1-25865
+                                                                         (cdr 
w-25212)))
+                                                                   (if (null? 
m1-25864)
+                                                                     (if 
(null? s1-25865)
+                                                                       w2-25863
+                                                                       (cons 
(car w2-25863)
+                                                                             
(let ((m2-25882
+                                                                               
      (cdr w2-25863)))
+                                                                               
(if (null? m2-25882)
+                                                                               
  s1-25865
                                                                                
  (append
-                                                                               
    s1-25704
-                                                                               
    m2-25721)))))
-                                                                     (cons 
(let ((m2-25729
-                                                                               
    (car w2-25702)))
-                                                                             
(if (null? m2-25729)
-                                                                               
m1-25703
+                                                                               
    s1-25865
+                                                                               
    m2-25882)))))
+                                                                     (cons 
(let ((m2-25890
+                                                                               
    (car w2-25863)))
+                                                                             
(if (null? m2-25890)
+                                                                               
m1-25864
                                                                                
(append
-                                                                               
  m1-25703
-                                                                               
  m2-25729)))
-                                                                           
(let ((m2-25737
-                                                                               
    (cdr w2-25702)))
-                                                                             
(if (null? m2-25737)
-                                                                               
s1-25704
+                                                                               
  m1-25864
+                                                                               
  m2-25890)))
+                                                                           
(let ((m2-25898
+                                                                               
    (cdr w2-25863)))
+                                                                             
(if (null? m2-25898)
+                                                                               
s1-25865
                                                                                
(append
-                                                                               
  s1-25704
-                                                                               
  m2-25737))))))))
-                                                             (module-25693
+                                                                               
  s1-25865
+                                                                               
  m2-25898))))))))
+                                                             (module-25854
                                                                (vector-ref
-                                                                 name-25658
+                                                                 name-25819
                                                                  3)))
                                                          (vector
                                                            'syntax-object
-                                                           expression-25691
-                                                           wrap-25692
-                                                           module-25693))
-                                                       (if (null? name-25658)
-                                                         name-25658
+                                                           expression-25852
+                                                           wrap-25853
+                                                           module-25854))
+                                                       (if (null? name-25819)
+                                                         name-25819
                                                          (vector
                                                            'syntax-object
-                                                           name-25658
-                                                           w-25086
-                                                           mod-25089))))
-                                                   (if (if (null? (car 
w-25086))
-                                                         (null? (cdr w-25086))
+                                                           name-25819
+                                                           w-25212
+                                                           mod-25215))))
+                                                   (if (if (null? (car 
w-25212))
+                                                         (null? (cdr w-25212))
                                                          #f)
-                                                     e-25084
-                                                     (if (if (vector? e-25084)
+                                                     e-25210
+                                                     (if (if (vector? e-25210)
                                                            (if (= 
(vector-length
-                                                                    e-25084)
+                                                                    e-25210)
                                                                   4)
                                                              (eq? (vector-ref
-                                                                    e-25084
+                                                                    e-25210
                                                                     0)
                                                                   
'syntax-object)
                                                              #f)
                                                            #f)
-                                                       (let ((expression-25789
+                                                       (let ((expression-25950
                                                                (vector-ref
-                                                                 e-25084
+                                                                 e-25210
                                                                  1))
-                                                             (wrap-25790
-                                                               (let ((w2-25800
+                                                             (wrap-25951
+                                                               (let ((w2-25961
                                                                        
(vector-ref
-                                                                         
e-25084
+                                                                         
e-25210
                                                                          2)))
-                                                                 (let 
((m1-25801
-                                                                         (car 
w-25086))
-                                                                       
(s1-25802
-                                                                         (cdr 
w-25086)))
-                                                                   (if (null? 
m1-25801)
-                                                                     (if 
(null? s1-25802)
-                                                                       w2-25800
-                                                                       (cons 
(car w2-25800)
-                                                                             
(let ((m2-25819
-                                                                               
      (cdr w2-25800)))
-                                                                               
(if (null? m2-25819)
-                                                                               
  s1-25802
+                                                                 (let 
((m1-25962
+                                                                         (car 
w-25212))
+                                                                       
(s1-25963
+                                                                         (cdr 
w-25212)))
+                                                                   (if (null? 
m1-25962)
+                                                                     (if 
(null? s1-25963)
+                                                                       w2-25961
+                                                                       (cons 
(car w2-25961)
+                                                                             
(let ((m2-25980
+                                                                               
      (cdr w2-25961)))
+                                                                               
(if (null? m2-25980)
+                                                                               
  s1-25963
                                                                                
  (append
-                                                                               
    s1-25802
-                                                                               
    m2-25819)))))
-                                                                     (cons 
(let ((m2-25827
-                                                                               
    (car w2-25800)))
-                                                                             
(if (null? m2-25827)
-                                                                               
m1-25801
+                                                                               
    s1-25963
+                                                                               
    m2-25980)))))
+                                                                     (cons 
(let ((m2-25988
+                                                                               
    (car w2-25961)))
+                                                                             
(if (null? m2-25988)
+                                                                               
m1-25962
                                                                                
(append
-                                                                               
  m1-25801
-                                                                               
  m2-25827)))
-                                                                           
(let ((m2-25835
-                                                                               
    (cdr w2-25800)))
-                                                                             
(if (null? m2-25835)
-                                                                               
s1-25802
+                                                                               
  m1-25962
+                                                                               
  m2-25988)))
+                                                                           
(let ((m2-25996
+                                                                               
    (cdr w2-25961)))
+                                                                             
(if (null? m2-25996)
+                                                                               
s1-25963
                                                                                
(append
-                                                                               
  s1-25802
-                                                                               
  m2-25835))))))))
-                                                             (module-25791
+                                                                               
  s1-25963
+                                                                               
  m2-25996))))))))
+                                                             (module-25952
                                                                (vector-ref
-                                                                 e-25084
+                                                                 e-25210
                                                                  3)))
                                                          (vector
                                                            'syntax-object
-                                                           expression-25789
-                                                           wrap-25790
-                                                           module-25791))
-                                                       (if (null? e-25084)
-                                                         e-25084
+                                                           expression-25950
+                                                           wrap-25951
+                                                           module-25952))
+                                                       (if (null? e-25210)
+                                                         e-25210
                                                          (vector
                                                            'syntax-object
-                                                           e-25084
-                                                           w-25086
-                                                           mod-25089))))
-                                                   (let ((e-25861
+                                                           e-25210
+                                                           w-25212
+                                                           mod-25215))))
+                                                   (let ((e-26022
                                                            (cons 
'#(syntax-object
                                                                     lambda
                                                                     ((top)
@@ -2183,10 +2183,19 @@
                                                                          (top)
                                                                          (top)
                                                                          (top))
-                                                                       
#("l-*-2021"
-                                                                         
"l-*-2022"
-                                                                         
"l-*-2023"
-                                                                         
"l-*-2024"))
+                                                                       
#("l-*-1959"
+                                                                         
"l-*-1960"
+                                                                         
"l-*-1961"
+                                                                         
"l-*-1962"))
+                                                                     #(ribcage
+                                                                       ()
+                                                                       ()
+                                                                       ())
+                                                                     #(ribcage
+                                                                       #(key)
+                                                                       
#((m-*-1924
+                                                                           
top))
+                                                                       
#("l-*-1925"))
                                                                      #(ribcage
                                                                        ()
                                                                        ()
@@ -2210,13 +2219,13 @@
                                                                          (top)
                                                                          (top)
                                                                          (top))
-                                                                       
#("l-*-1973"
-                                                                         
"l-*-1974"
-                                                                         
"l-*-1975"
-                                                                         
"l-*-1976"
-                                                                         
"l-*-1977"
-                                                                         
"l-*-1978"
-                                                                         
"l-*-1979"))
+                                                                       
#("l-*-1917"
+                                                                         
"l-*-1918"
+                                                                         
"l-*-1919"
+                                                                         
"l-*-1920"
+                                                                         
"l-*-1921"
+                                                                         
"l-*-1922"
+                                                                         
"l-*-1923"))
                                                                      #(ribcage
                                                                        ()
                                                                        ()
@@ -2224,11 +2233,7 @@
                                                                      #(ribcage
                                                                        #(first)
                                                                        #((top))
-                                                                       
#("l-*-1964"))
-                                                                     #(ribcage
-                                                                       ()
-                                                                       ()
-                                                                       ())
+                                                                       
#("l-*-1908"))
                                                                      #(ribcage
                                                                        ()
                                                                        ()
@@ -2252,13 +2257,13 @@
                                                                          (top)
                                                                          (top)
                                                                          (top))
-                                                                       
#("l-*-1943"
-                                                                         
"l-*-1944"
-                                                                         
"l-*-1945"
-                                                                         
"l-*-1946"
-                                                                         
"l-*-1947"
-                                                                         
"l-*-1948"
-                                                                         
"l-*-1949"))
+                                                                       
#("l-*-1890"
+                                                                         
"l-*-1891"
+                                                                         
"l-*-1892"
+                                                                         
"l-*-1893"
+                                                                         
"l-*-1894"
+                                                                         
"l-*-1895"
+                                                                         
"l-*-1896"))
                                                                      #(ribcage
                                                                        
(lambda-var-list
                                                                          
gen-var
@@ -2699,268 +2704,273 @@
                                                                        ()))
                                                                     (hygiene
                                                                       guile))
-                                                                 (let ((x-25865
-                                                                         (cons 
args-25659
-                                                                               
(cons e1-25660
-                                                                               
      e2-25661))))
-                                                                   (if (if 
(null? (car w-25086))
-                                                                         
(null? (cdr w-25086))
+                                                                 (let ((x-26026
+                                                                         (cons 
args-25820
+                                                                               
(cons e1-25821
+                                                                               
      e2-25822))))
+                                                                   (if (if 
(null? (car w-25212))
+                                                                         
(null? (cdr w-25212))
                                                                          #f)
-                                                                     x-25865
+                                                                     x-26026
                                                                      (if (if 
(vector?
-                                                                               
x-25865)
+                                                                               
x-26026)
                                                                            (if 
(= (vector-length
-                                                                               
     x-25865)
+                                                                               
     x-26026)
                                                                                
   4)
                                                                              
(eq? (vector-ref
-                                                                               
     x-25865
+                                                                               
     x-26026
                                                                                
     0)
                                                                                
   'syntax-object)
                                                                              
#f)
                                                                            #f)
-                                                                       (let 
((expression-25883
+                                                                       (let 
((expression-26044
                                                                                
(vector-ref
-                                                                               
  x-25865
+                                                                               
  x-26026
                                                                                
  1))
-                                                                             
(wrap-25884
-                                                                               
(let ((w2-25892
+                                                                             
(wrap-26045
+                                                                               
(let ((w2-26053
                                                                                
        (vector-ref
-                                                                               
          x-25865
+                                                                               
          x-26026
                                                                                
          2)))
-                                                                               
  (let ((m1-25893
-                                                                               
          (car w-25086))
-                                                                               
        (s1-25894
-                                                                               
          (cdr w-25086)))
-                                                                               
    (if (null? m1-25893)
-                                                                               
      (if (null? s1-25894)
-                                                                               
        w2-25892
-                                                                               
        (cons (car w2-25892)
-                                                                               
              (let ((m2-25909
-                                                                               
                      (cdr w2-25892)))
-                                                                               
                (if (null? m2-25909)
-                                                                               
                  s1-25894
+                                                                               
  (let ((m1-26054
+                                                                               
          (car w-25212))
+                                                                               
        (s1-26055
+                                                                               
          (cdr w-25212)))
+                                                                               
    (if (null? m1-26054)
+                                                                               
      (if (null? s1-26055)
+                                                                               
        w2-26053
+                                                                               
        (cons (car w2-26053)
+                                                                               
              (let ((m2-26070
+                                                                               
                      (cdr w2-26053)))
+                                                                               
                (if (null? m2-26070)
+                                                                               
                  s1-26055
                                                                                
                  (append
-                                                                               
                    s1-25894
-                                                                               
                    m2-25909)))))
-                                                                               
      (cons (let ((m2-25917
-                                                                               
                    (car w2-25892)))
-                                                                               
              (if (null? m2-25917)
-                                                                               
                m1-25893
+                                                                               
                    s1-26055
+                                                                               
                    m2-26070)))))
+                                                                               
      (cons (let ((m2-26078
+                                                                               
                    (car w2-26053)))
+                                                                               
              (if (null? m2-26078)
+                                                                               
                m1-26054
                                                                                
                (append
-                                                                               
                  m1-25893
-                                                                               
                  m2-25917)))
-                                                                               
            (let ((m2-25925
-                                                                               
                    (cdr w2-25892)))
-                                                                               
              (if (null? m2-25925)
-                                                                               
                s1-25894
+                                                                               
                  m1-26054
+                                                                               
                  m2-26078)))
+                                                                               
            (let ((m2-26086
+                                                                               
                    (cdr w2-26053)))
+                                                                               
              (if (null? m2-26086)
+                                                                               
                s1-26055
                                                                                
                (append
-                                                                               
                  s1-25894
-                                                                               
                  m2-25925))))))))
-                                                                             
(module-25885
+                                                                               
                  s1-26055
+                                                                               
                  m2-26086))))))))
+                                                                             
(module-26046
                                                                                
(vector-ref
-                                                                               
  x-25865
+                                                                               
  x-26026
                                                                                
  3)))
                                                                          
(vector
                                                                            
'syntax-object
-                                                                           
expression-25883
-                                                                           
wrap-25884
-                                                                           
module-25885))
-                                                                       (if 
(null? x-25865)
-                                                                         
x-25865
+                                                                           
expression-26044
+                                                                           
wrap-26045
+                                                                           
module-26046))
+                                                                       (if 
(null? x-26026)
+                                                                         
x-26026
                                                                          
(vector
                                                                            
'syntax-object
-                                                                           
x-25865
-                                                                           
w-25086
-                                                                           
mod-25089))))))))
+                                                                           
x-26026
+                                                                           
w-25212
+                                                                           
mod-25215))))))))
                                                      (begin
-                                                       (if (if (pair? e-25861)
-                                                             s-25087
+                                                       (if (if (pair? e-26022)
+                                                             s-25213
                                                              #f)
                                                          
(set-source-properties!
-                                                           e-25861
-                                                           s-25087))
-                                                       e-25861))
+                                                           e-26022
+                                                           s-25213))
+                                                       e-26022))
                                                    '(())
-                                                   s-25087
-                                                   mod-25089))
-                                               tmp-25188)
-                                             (let ((tmp-25944
+                                                   s-25213
+                                                   mod-25215))
+                                               tmp-25349)
+                                             (let ((tmp-26105
                                                      ($sc-dispatch
-                                                       e-25084
+                                                       e-25210
                                                        '(_ any))))
-                                               (if (if tmp-25944
+                                               (if (if tmp-26105
                                                      (@apply
-                                                       (lambda (name-25948)
+                                                       (lambda (name-26109)
                                                          (if (symbol?
-                                                               name-25948)
+                                                               name-26109)
                                                            #t
                                                            (if (if (vector?
-                                                                     
name-25948)
+                                                                     
name-26109)
                                                                  (if (= 
(vector-length
-                                                                          
name-25948)
+                                                                          
name-26109)
                                                                         4)
                                                                    (eq? 
(vector-ref
-                                                                          
name-25948
+                                                                          
name-26109
                                                                           0)
                                                                         
'syntax-object)
                                                                    #f)
                                                                  #f)
                                                              (symbol?
                                                                (vector-ref
-                                                                 name-25948
+                                                                 name-26109
                                                                  1))
                                                              #f)))
-                                                       tmp-25944)
+                                                       tmp-26105)
                                                      #f)
                                                  (@apply
-                                                   (lambda (name-25975)
+                                                   (lambda (name-26136)
                                                      (values
                                                        'define-form
-                                                       (if (if (null? (car 
w-25086))
-                                                             (null? (cdr 
w-25086))
+                                                       (if (if (null? (car 
w-25212))
+                                                             (null? (cdr 
w-25212))
                                                              #f)
-                                                         name-25975
+                                                         name-26136
                                                          (if (if (vector?
-                                                                   name-25975)
+                                                                   name-26136)
                                                                (if (= 
(vector-length
-                                                                        
name-25975)
+                                                                        
name-26136)
                                                                       4)
                                                                  (eq? 
(vector-ref
-                                                                        
name-25975
+                                                                        
name-26136
                                                                         0)
                                                                       
'syntax-object)
                                                                  #f)
                                                                #f)
-                                                           (let 
((expression-26005
+                                                           (let 
((expression-26166
                                                                    (vector-ref
-                                                                     name-25975
+                                                                     name-26136
                                                                      1))
-                                                                 (wrap-26006
-                                                                   (let 
((w2-26016
+                                                                 (wrap-26167
+                                                                   (let 
((w2-26177
                                                                            
(vector-ref
-                                                                             
name-25975
+                                                                             
name-26136
                                                                              
2)))
-                                                                     (let 
((m1-26017
-                                                                             
(car w-25086))
-                                                                           
(s1-26018
-                                                                             
(cdr w-25086)))
-                                                                       (if 
(null? m1-26017)
-                                                                         (if 
(null? s1-26018)
-                                                                           
w2-26016
-                                                                           
(cons (car w2-26016)
-                                                                               
  (let ((m2-26035
-                                                                               
          (cdr w2-26016)))
-                                                                               
    (if (null? m2-26035)
-                                                                               
      s1-26018
+                                                                     (let 
((m1-26178
+                                                                             
(car w-25212))
+                                                                           
(s1-26179
+                                                                             
(cdr w-25212)))
+                                                                       (if 
(null? m1-26178)
+                                                                         (if 
(null? s1-26179)
+                                                                           
w2-26177
+                                                                           
(cons (car w2-26177)
+                                                                               
  (let ((m2-26196
+                                                                               
          (cdr w2-26177)))
+                                                                               
    (if (null? m2-26196)
+                                                                               
      s1-26179
                                                                                
      (append
-                                                                               
        s1-26018
-                                                                               
        m2-26035)))))
-                                                                         (cons 
(let ((m2-26043
-                                                                               
        (car w2-26016)))
-                                                                               
  (if (null? m2-26043)
-                                                                               
    m1-26017
+                                                                               
        s1-26179
+                                                                               
        m2-26196)))))
+                                                                         (cons 
(let ((m2-26204
+                                                                               
        (car w2-26177)))
+                                                                               
  (if (null? m2-26204)
+                                                                               
    m1-26178
                                                                                
    (append
-                                                                               
      m1-26017
-                                                                               
      m2-26043)))
-                                                                               
(let ((m2-26051
-                                                                               
        (cdr w2-26016)))
-                                                                               
  (if (null? m2-26051)
-                                                                               
    s1-26018
+                                                                               
      m1-26178
+                                                                               
      m2-26204)))
+                                                                               
(let ((m2-26212
+                                                                               
        (cdr w2-26177)))
+                                                                               
  (if (null? m2-26212)
+                                                                               
    s1-26179
                                                                                
    (append
-                                                                               
      s1-26018
-                                                                               
      m2-26051))))))))
-                                                                 (module-26007
+                                                                               
      s1-26179
+                                                                               
      m2-26212))))))))
+                                                                 (module-26168
                                                                    (vector-ref
-                                                                     name-25975
+                                                                     name-26136
                                                                      3)))
                                                              (vector
                                                                'syntax-object
-                                                               expression-26005
-                                                               wrap-26006
-                                                               module-26007))
-                                                           (if (null? 
name-25975)
-                                                             name-25975
+                                                               expression-26166
+                                                               wrap-26167
+                                                               module-26168))
+                                                           (if (null? 
name-26136)
+                                                             name-26136
                                                              (vector
                                                                'syntax-object
-                                                               name-25975
-                                                               w-25086
-                                                               mod-25089))))
-                                                       (if (if (null? (car 
w-25086))
-                                                             (null? (cdr 
w-25086))
+                                                               name-26136
+                                                               w-25212
+                                                               mod-25215))))
+                                                       (if (if (null? (car 
w-25212))
+                                                             (null? (cdr 
w-25212))
                                                              #f)
-                                                         e-25084
+                                                         e-25210
                                                          (if (if (vector?
-                                                                   e-25084)
+                                                                   e-25210)
                                                                (if (= 
(vector-length
-                                                                        
e-25084)
+                                                                        
e-25210)
                                                                       4)
                                                                  (eq? 
(vector-ref
-                                                                        e-25084
+                                                                        e-25210
                                                                         0)
                                                                       
'syntax-object)
                                                                  #f)
                                                                #f)
-                                                           (let 
((expression-26103
+                                                           (let 
((expression-26264
                                                                    (vector-ref
-                                                                     e-25084
+                                                                     e-25210
                                                                      1))
-                                                                 (wrap-26104
-                                                                   (let 
((w2-26114
+                                                                 (wrap-26265
+                                                                   (let 
((w2-26275
                                                                            
(vector-ref
-                                                                             
e-25084
+                                                                             
e-25210
                                                                              
2)))
-                                                                     (let 
((m1-26115
-                                                                             
(car w-25086))
-                                                                           
(s1-26116
-                                                                             
(cdr w-25086)))
-                                                                       (if 
(null? m1-26115)
-                                                                         (if 
(null? s1-26116)
-                                                                           
w2-26114
-                                                                           
(cons (car w2-26114)
-                                                                               
  (let ((m2-26133
-                                                                               
          (cdr w2-26114)))
-                                                                               
    (if (null? m2-26133)
-                                                                               
      s1-26116
+                                                                     (let 
((m1-26276
+                                                                             
(car w-25212))
+                                                                           
(s1-26277
+                                                                             
(cdr w-25212)))
+                                                                       (if 
(null? m1-26276)
+                                                                         (if 
(null? s1-26277)
+                                                                           
w2-26275
+                                                                           
(cons (car w2-26275)
+                                                                               
  (let ((m2-26294
+                                                                               
          (cdr w2-26275)))
+                                                                               
    (if (null? m2-26294)
+                                                                               
      s1-26277
                                                                                
      (append
-                                                                               
        s1-26116
-                                                                               
        m2-26133)))))
-                                                                         (cons 
(let ((m2-26141
-                                                                               
        (car w2-26114)))
-                                                                               
  (if (null? m2-26141)
-                                                                               
    m1-26115
+                                                                               
        s1-26277
+                                                                               
        m2-26294)))))
+                                                                         (cons 
(let ((m2-26302
+                                                                               
        (car w2-26275)))
+                                                                               
  (if (null? m2-26302)
+                                                                               
    m1-26276
                                                                                
    (append
-                                                                               
      m1-26115
-                                                                               
      m2-26141)))
-                                                                               
(let ((m2-26149
-                                                                               
        (cdr w2-26114)))
-                                                                               
  (if (null? m2-26149)
-                                                                               
    s1-26116
+                                                                               
      m1-26276
+                                                                               
      m2-26302)))
+                                                                               
(let ((m2-26310
+                                                                               
        (cdr w2-26275)))
+                                                                               
  (if (null? m2-26310)
+                                                                               
    s1-26277
                                                                                
    (append
-                                                                               
      s1-26116
-                                                                               
      m2-26149))))))))
-                                                                 (module-26105
+                                                                               
      s1-26277
+                                                                               
      m2-26310))))))))
+                                                                 (module-26266
                                                                    (vector-ref
-                                                                     e-25084
+                                                                     e-25210
                                                                      3)))
                                                              (vector
                                                                'syntax-object
-                                                               expression-26103
-                                                               wrap-26104
-                                                               module-26105))
-                                                           (if (null? e-25084)
-                                                             e-25084
+                                                               expression-26264
+                                                               wrap-26265
+                                                               module-26266))
+                                                           (if (null? e-25210)
+                                                             e-25210
                                                              (vector
                                                                'syntax-object
-                                                               e-25084
-                                                               w-25086
-                                                               mod-25089))))
+                                                               e-25210
+                                                               w-25212
+                                                               mod-25215))))
                                                        '(#(syntax-object
                                                            if
                                                            ((top)
                                                             #(ribcage
                                                               #(name)
                                                               #((top))
-                                                              #("l-*-2034"))
+                                                              #("l-*-1972"))
+                                                            #(ribcage () () ())
+                                                            #(ribcage
+                                                              #(key)
+                                                              #((m-*-1924 top))
+                                                              #("l-*-1925"))
                                                             #(ribcage () () ())
                                                             #(ribcage () () ())
                                                             #(ribcage
@@ -2978,19 +2988,18 @@
                                                                 (top)
                                                                 (top)
                                                                 (top))
-                                                              #("l-*-1973"
-                                                                "l-*-1974"
-                                                                "l-*-1975"
-                                                                "l-*-1976"
-                                                                "l-*-1977"
-                                                                "l-*-1978"
-                                                                "l-*-1979"))
+                                                              #("l-*-1917"
+                                                                "l-*-1918"
+                                                                "l-*-1919"
+                                                                "l-*-1920"
+                                                                "l-*-1921"
+                                                                "l-*-1922"
+                                                                "l-*-1923"))
                                                             #(ribcage () () ())
                                                             #(ribcage
                                                               #(first)
                                                               #((top))
-                                                              #("l-*-1964"))
-                                                            #(ribcage () () ())
+                                                              #("l-*-1908"))
                                                             #(ribcage () () ())
                                                             #(ribcage () () ())
                                                             #(ribcage
@@ -3008,13 +3017,13 @@
                                                                 (top)
                                                                 (top)
                                                                 (top))
-                                                              #("l-*-1943"
-                                                                "l-*-1944"
-                                                                "l-*-1945"
-                                                                "l-*-1946"
-                                                                "l-*-1947"
-                                                                "l-*-1948"
-                                                                "l-*-1949"))
+                                                              #("l-*-1890"
+                                                                "l-*-1891"
+                                                                "l-*-1892"
+                                                                "l-*-1893"
+                                                                "l-*-1894"
+                                                                "l-*-1895"
+                                                                "l-*-1896"))
                                                             #(ribcage
                                                               (lambda-var-list
                                                                 gen-var
@@ -3460,7 +3469,12 @@
                                                             #(ribcage
                                                               #(name)
                                                               #((top))
-                                                              #("l-*-2034"))
+                                                              #("l-*-1972"))
+                                                            #(ribcage () () ())
+                                                            #(ribcage
+                                                              #(key)
+                                                              #((m-*-1924 top))
+                                                              #("l-*-1925"))
                                                             #(ribcage () () ())
                                                             #(ribcage () () ())
                                                             #(ribcage
@@ -3478,19 +3492,18 @@
                                                                 (top)
                                                                 (top)
                                                                 (top))
-                                                              #("l-*-1973"
-                                                                "l-*-1974"
-                                                                "l-*-1975"
-                                                                "l-*-1976"
-                                                                "l-*-1977"
-                                                                "l-*-1978"
-                                                                "l-*-1979"))
+                                                              #("l-*-1917"
+                                                                "l-*-1918"
+                                                                "l-*-1919"
+                                                                "l-*-1920"
+                                                                "l-*-1921"
+                                                                "l-*-1922"
+                                                                "l-*-1923"))
                                                             #(ribcage () () ())
                                                             #(ribcage
                                                               #(first)
                                                               #((top))
-                                                              #("l-*-1964"))
-                                                            #(ribcage () () ())
+                                                              #("l-*-1908"))
                                                             #(ribcage () () ())
                                                             #(ribcage () () ())
                                                             #(ribcage
@@ -3508,13 +3521,13 @@
                                                                 (top)
                                                                 (top)
                                                                 (top))
-                                                              #("l-*-1943"
-                                                                "l-*-1944"
-                                                                "l-*-1945"
-                                                                "l-*-1946"
-                                                                "l-*-1947"
-                                                                "l-*-1948"
-                                                                "l-*-1949"))
+                                                              #("l-*-1890"
+                                                                "l-*-1891"
+                                                                "l-*-1892"
+                                                                "l-*-1893"
+                                                                "l-*-1894"
+                                                                "l-*-1895"
+                                                                "l-*-1896"))
                                                             #(ribcage
                                                               (lambda-var-list
                                                                 gen-var
@@ -3960,7 +3973,12 @@
                                                             #(ribcage
                                                               #(name)
                                                               #((top))
-                                                              #("l-*-2034"))
+                                                              #("l-*-1972"))
+                                                            #(ribcage () () ())
+                                                            #(ribcage
+                                                              #(key)
+                                                              #((m-*-1924 top))
+                                                              #("l-*-1925"))
                                                             #(ribcage () () ())
                                                             #(ribcage () () ())
                                                             #(ribcage
@@ -3978,19 +3996,18 @@
                                                                 (top)
                                                                 (top)
                                                                 (top))
-                                                              #("l-*-1973"
-                                                                "l-*-1974"
-                                                                "l-*-1975"
-                                                                "l-*-1976"
-                                                                "l-*-1977"
-                                                                "l-*-1978"
-                                                                "l-*-1979"))
+                                                              #("l-*-1917"
+                                                                "l-*-1918"
+                                                                "l-*-1919"
+                                                                "l-*-1920"
+                                                                "l-*-1921"
+                                                                "l-*-1922"
+                                                                "l-*-1923"))
                                                             #(ribcage () () ())
                                                             #(ribcage
                                                               #(first)
                                                               #((top))
-                                                              #("l-*-1964"))
-                                                            #(ribcage () () ())
+                                                              #("l-*-1908"))
                                                             #(ribcage () () ())
                                                             #(ribcage () () ())
                                                             #(ribcage
@@ -4008,13 +4025,13 @@
                                                                 (top)
                                                                 (top)
                                                                 (top))
-                                                              #("l-*-1943"
-                                                                "l-*-1944"
-                                                                "l-*-1945"
-                                                                "l-*-1946"
-                                                                "l-*-1947"
-                                                                "l-*-1948"
-                                                                "l-*-1949"))
+                                                              #("l-*-1890"
+                                                                "l-*-1891"
+                                                                "l-*-1892"
+                                                                "l-*-1893"
+                                                                "l-*-1894"
+                                                                "l-*-1895"
+                                                                "l-*-1896"))
                                                             #(ribcage
                                                               (lambda-var-list
                                                                 gen-var
@@ -4455,2122 +4472,2122 @@
                                                               ()))
                                                            (hygiene guile)))
                                                        '(())
-                                                       s-25087
-                                                       mod-25089))
-                                                   tmp-25944)
+                                                       s-25213
+                                                       mod-25215))
+                                                   tmp-26105)
                                                  (syntax-violation
                                                    #f
                                                    "source expression failed 
to match any pattern"
-                                                   e-25084)))))))
-                                     (if (eqv? ftype-25106 'define-syntax)
-                                       (let ((tmp-26188
+                                                   e-25210)))))))
+                                     (if (eqv? ftype-25239 'define-syntax)
+                                       (let ((tmp-26352
                                                ($sc-dispatch
-                                                 e-25084
+                                                 e-25210
                                                  '(_ any any))))
-                                         (if (if tmp-26188
+                                         (if (if tmp-26352
                                                (@apply
-                                                 (lambda (name-26192 val-26193)
-                                                   (if (symbol? name-26192)
+                                                 (lambda (name-26356 val-26357)
+                                                   (if (symbol? name-26356)
                                                      #t
                                                      (if (if (vector?
-                                                               name-26192)
+                                                               name-26356)
                                                            (if (= 
(vector-length
-                                                                    name-26192)
+                                                                    name-26356)
                                                                   4)
                                                              (eq? (vector-ref
-                                                                    name-26192
+                                                                    name-26356
                                                                     0)
                                                                   
'syntax-object)
                                                              #f)
                                                            #f)
                                                        (symbol?
                                                          (vector-ref
-                                                           name-26192
+                                                           name-26356
                                                            1))
                                                        #f)))
-                                                 tmp-26188)
+                                                 tmp-26352)
                                                #f)
                                            (@apply
-                                             (lambda (name-26220 val-26221)
+                                             (lambda (name-26384 val-26385)
                                                (values
                                                  'define-syntax-form
-                                                 name-26220
-                                                 e-25084
-                                                 val-26221
-                                                 w-25086
-                                                 s-25087
-                                                 mod-25089))
-                                             tmp-26188)
+                                                 name-26384
+                                                 e-25210
+                                                 val-26385
+                                                 w-25212
+                                                 s-25213
+                                                 mod-25215))
+                                             tmp-26352)
                                            (syntax-violation
                                              #f
                                              "source expression failed to 
match any pattern"
-                                             e-25084)))
-                                       (if (eqv? ftype-25106
+                                             e-25210)))
+                                       (if (eqv? ftype-25239
                                                  'define-syntax-parameter)
-                                         (let ((tmp-26232
+                                         (let ((tmp-26399
                                                  ($sc-dispatch
-                                                   e-25084
+                                                   e-25210
                                                    '(_ any any))))
-                                           (if (if tmp-26232
+                                           (if (if tmp-26399
                                                  (@apply
-                                                   (lambda (name-26236
-                                                            val-26237)
-                                                     (if (symbol? name-26236)
+                                                   (lambda (name-26403
+                                                            val-26404)
+                                                     (if (symbol? name-26403)
                                                        #t
                                                        (if (if (vector?
-                                                                 name-26236)
+                                                                 name-26403)
                                                              (if (= 
(vector-length
-                                                                      
name-26236)
+                                                                      
name-26403)
                                                                     4)
                                                                (eq? (vector-ref
-                                                                      
name-26236
+                                                                      
name-26403
                                                                       0)
                                                                     
'syntax-object)
                                                                #f)
                                                              #f)
                                                          (symbol?
                                                            (vector-ref
-                                                             name-26236
+                                                             name-26403
                                                              1))
                                                          #f)))
-                                                   tmp-26232)
+                                                   tmp-26399)
                                                  #f)
                                              (@apply
-                                               (lambda (name-26264 val-26265)
+                                               (lambda (name-26431 val-26432)
                                                  (values
                                                    
'define-syntax-parameter-form
-                                                   name-26264
-                                                   e-25084
-                                                   val-26265
-                                                   w-25086
-                                                   s-25087
-                                                   mod-25089))
-                                               tmp-26232)
+                                                   name-26431
+                                                   e-25210
+                                                   val-26432
+                                                   w-25212
+                                                   s-25213
+                                                   mod-25215))
+                                               tmp-26399)
                                              (syntax-violation
                                                #f
                                                "source expression failed to 
match any pattern"
-                                               e-25084)))
+                                               e-25210)))
                                          (values
                                            'call
                                            #f
-                                           e-25084
-                                           e-25084
-                                           w-25086
-                                           s-25087
-                                           mod-25089)))))))))))))))
-             (if (if (vector? e-25084)
-                   (if (= (vector-length e-25084) 4)
-                     (eq? (vector-ref e-25084 0) 'syntax-object)
+                                           e-25210
+                                           e-25210
+                                           w-25212
+                                           s-25213
+                                           mod-25215)))))))))))))))
+             (if (if (vector? e-25210)
+                   (if (= (vector-length e-25210) 4)
+                     (eq? (vector-ref e-25210 0) 'syntax-object)
                      #f)
                    #f)
-               (syntax-type-4585
-                 (vector-ref e-25084 1)
-                 r-25085
-                 (let ((w2-26290 (vector-ref e-25084 2)))
-                   (let ((m1-26291 (car w-25086))
-                         (s1-26292 (cdr w-25086)))
-                     (if (null? m1-26291)
-                       (if (null? s1-26292)
-                         w2-26290
-                         (cons (car w2-26290)
-                               (let ((m2-26303 (cdr w2-26290)))
-                                 (if (null? m2-26303)
-                                   s1-26292
-                                   (append s1-26292 m2-26303)))))
-                       (cons (let ((m2-26311 (car w2-26290)))
-                               (if (null? m2-26311)
-                                 m1-26291
-                                 (append m1-26291 m2-26311)))
-                             (let ((m2-26319 (cdr w2-26290)))
-                               (if (null? m2-26319)
-                                 s1-26292
-                                 (append s1-26292 m2-26319)))))))
-                 (let ((t-26324 (source-annotation-4544 e-25084)))
-                   (if t-26324 t-26324 s-25087))
-                 rib-25088
-                 (let ((t-26600 (vector-ref e-25084 3)))
-                   (if t-26600 t-26600 mod-25089))
-                 for-car?-25090)
-               (if (self-evaluating? e-25084)
+               (syntax-type-4381
+                 (vector-ref e-25210 1)
+                 r-25211
+                 (let ((w2-26457 (vector-ref e-25210 2)))
+                   (let ((m1-26458 (car w-25212))
+                         (s1-26459 (cdr w-25212)))
+                     (if (null? m1-26458)
+                       (if (null? s1-26459)
+                         w2-26457
+                         (cons (car w2-26457)
+                               (let ((m2-26470 (cdr w2-26457)))
+                                 (if (null? m2-26470)
+                                   s1-26459
+                                   (append s1-26459 m2-26470)))))
+                       (cons (let ((m2-26478 (car w2-26457)))
+                               (if (null? m2-26478)
+                                 m1-26458
+                                 (append m1-26458 m2-26478)))
+                             (let ((m2-26486 (cdr w2-26457)))
+                               (if (null? m2-26486)
+                                 s1-26459
+                                 (append s1-26459 m2-26486)))))))
+                 (let ((t-26491 (source-annotation-4340 e-25210)))
+                   (if t-26491 t-26491 s-25213))
+                 rib-25214
+                 (let ((t-26767 (vector-ref e-25210 3)))
+                   (if t-26767 t-26767 mod-25215))
+                 for-car?-25216)
+               (if (self-evaluating? e-25210)
                  (values
                    'constant
                    #f
-                   e-25084
-                   e-25084
-                   w-25086
-                   s-25087
-                   mod-25089)
+                   e-25210
+                   e-25210
+                   w-25212
+                   s-25213
+                   mod-25215)
                  (values
                    'other
                    #f
-                   e-25084
-                   e-25084
-                   w-25086
-                   s-25087
-                   mod-25089)))))))
-     (expand-4586
-       (lambda (e-26609 r-26610 w-26611 mod-26612)
+                   e-25210
+                   e-25210
+                   w-25212
+                   s-25213
+                   mod-25215)))))))
+     (expand-4382
+       (lambda (e-26776 r-26777 w-26778 mod-26779)
          (call-with-values
            (lambda ()
-             (syntax-type-4585
-               e-26609
-               r-26610
-               w-26611
-               (source-annotation-4544 e-26609)
+             (syntax-type-4381
+               e-26776
+               r-26777
+               w-26778
+               (source-annotation-4340 e-26776)
                #f
-               mod-26612
+               mod-26779
                #f))
-           (lambda (type-26798
-                    value-26799
-                    form-26800
-                    e-26801
-                    w-26802
-                    s-26803
-                    mod-26804)
-             (expand-expr-4587
-               type-26798
-               value-26799
-               form-26800
-               e-26801
-               r-26610
-               w-26802
-               s-26803
-               mod-26804)))))
-     (expand-expr-4587
-       (lambda (type-26807
-                value-26808
-                form-26809
-                e-26810
-                r-26811
-                w-26812
-                s-26813
-                mod-26814)
-         (if (eqv? type-26807 'lexical)
+           (lambda (type-26965
+                    value-26966
+                    form-26967
+                    e-26968
+                    w-26969
+                    s-26970
+                    mod-26971)
+             (expand-expr-4383
+               type-26965
+               value-26966
+               form-26967
+               e-26968
+               r-26777
+               w-26969
+               s-26970
+               mod-26971)))))
+     (expand-expr-4383
+       (lambda (type-26974
+                value-26975
+                form-26976
+                e-26977
+                r-26978
+                w-26979
+                s-26980
+                mod-26981)
+         (if (eqv? type-26974 'lexical)
            (make-struct/no-tail
              (vector-ref %expanded-vtables 3)
-             s-26813
-             e-26810
-             value-26808)
-           (if (if (eqv? type-26807 'core)
+             s-26980
+             e-26977
+             value-26975)
+           (if (if (eqv? type-26974 'core)
                  #t
-                 (eqv? type-26807 'core-form))
-             (value-26808
-               e-26810
-               r-26811
-               w-26812
-               s-26813
-               mod-26814)
-             (if (eqv? type-26807 'module-ref)
+                 (eqv? type-26974 'core-form))
+             (value-26975
+               e-26977
+               r-26978
+               w-26979
+               s-26980
+               mod-26981)
+             (if (eqv? type-26974 'module-ref)
                (call-with-values
-                 (lambda () (value-26808 e-26810 r-26811 w-26812))
-                 (lambda (e-26840 r-26841 w-26842 s-26843 mod-26844)
-                   (expand-4586 e-26840 r-26841 w-26842 mod-26844)))
-               (if (eqv? type-26807 'lexical-call)
-                 (expand-call-4588
-                   (let ((id-27017 (car e-26810)))
-                     (build-lexical-reference-4520
+                 (lambda () (value-26975 e-26977 r-26978 w-26979))
+                 (lambda (e-27017 r-27018 w-27019 s-27020 mod-27021)
+                   (expand-4382 e-27017 r-27018 w-27019 mod-27021)))
+               (if (eqv? type-26974 'lexical-call)
+                 (expand-call-4384
+                   (let ((id-27197 (car e-26977)))
+                     (build-lexical-reference-4316
                        'fun
-                       (source-annotation-4544 id-27017)
-                       (if (if (vector? id-27017)
-                             (if (= (vector-length id-27017) 4)
-                               (eq? (vector-ref id-27017 0) 'syntax-object)
+                       (source-annotation-4340 id-27197)
+                       (if (if (vector? id-27197)
+                             (if (= (vector-length id-27197) 4)
+                               (eq? (vector-ref id-27197 0) 'syntax-object)
                                #f)
                              #f)
-                         (syntax->datum id-27017)
-                         id-27017)
-                       value-26808))
-                   e-26810
-                   r-26811
-                   w-26812
-                   s-26813
-                   mod-26814)
-                 (if (eqv? type-26807 'global-call)
-                   (expand-call-4588
-                     (build-global-reference-4523
-                       (source-annotation-4544 (car e-26810))
-                       (if (if (vector? value-26808)
-                             (if (= (vector-length value-26808) 4)
-                               (eq? (vector-ref value-26808 0) 'syntax-object)
+                         (syntax->datum id-27197)
+                         id-27197)
+                       value-26975))
+                   e-26977
+                   r-26978
+                   w-26979
+                   s-26980
+                   mod-26981)
+                 (if (eqv? type-26974 'global-call)
+                   (expand-call-4384
+                     (build-global-reference-4319
+                       (source-annotation-4340 (car e-26977))
+                       (if (if (vector? value-26975)
+                             (if (= (vector-length value-26975) 4)
+                               (eq? (vector-ref value-26975 0) 'syntax-object)
                                #f)
                              #f)
-                         (vector-ref value-26808 1)
-                         value-26808)
-                       (if (if (vector? value-26808)
-                             (if (= (vector-length value-26808) 4)
-                               (eq? (vector-ref value-26808 0) 'syntax-object)
+                         (vector-ref value-26975 1)
+                         value-26975)
+                       (if (if (vector? value-26975)
+                             (if (= (vector-length value-26975) 4)
+                               (eq? (vector-ref value-26975 0) 'syntax-object)
                                #f)
                              #f)
-                         (vector-ref value-26808 3)
-                         mod-26814))
-                     e-26810
-                     r-26811
-                     w-26812
-                     s-26813
-                     mod-26814)
-                   (if (eqv? type-26807 'constant)
-                     (let ((exp-27691
-                             (strip-4599
-                               (let ((x-27704
+                         (vector-ref value-26975 3)
+                         mod-26981))
+                     e-26977
+                     r-26978
+                     w-26979
+                     s-26980
+                     mod-26981)
+                   (if (eqv? type-26974 'constant)
+                     (let ((exp-27877
+                             (strip-4395
+                               (let ((x-27890
                                        (begin
-                                         (if (if (pair? e-26810) s-26813 #f)
+                                         (if (if (pair? e-26977) s-26980 #f)
                                            (set-source-properties!
-                                             e-26810
-                                             s-26813))
-                                         e-26810)))
-                                 (if (if (null? (car w-26812))
-                                       (null? (cdr w-26812))
+                                             e-26977
+                                             s-26980))
+                                         e-26977)))
+                                 (if (if (null? (car w-26979))
+                                       (null? (cdr w-26979))
                                        #f)
-                                   x-27704
-                                   (if (if (vector? x-27704)
-                                         (if (= (vector-length x-27704) 4)
-                                           (eq? (vector-ref x-27704 0)
+                                   x-27890
+                                   (if (if (vector? x-27890)
+                                         (if (= (vector-length x-27890) 4)
+                                           (eq? (vector-ref x-27890 0)
                                                 'syntax-object)
                                            #f)
                                          #f)
-                                     (let ((expression-27736
-                                             (vector-ref x-27704 1))
-                                           (wrap-27737
-                                             (let ((w2-27745
-                                                     (vector-ref x-27704 2)))
-                                               (let ((m1-27746 (car w-26812))
-                                                     (s1-27747 (cdr w-26812)))
-                                                 (if (null? m1-27746)
-                                                   (if (null? s1-27747)
-                                                     w2-27745
-                                                     (cons (car w2-27745)
-                                                           (let ((m2-27762
-                                                                   (cdr 
w2-27745)))
-                                                             (if (null? 
m2-27762)
-                                                               s1-27747
+                                     (let ((expression-27922
+                                             (vector-ref x-27890 1))
+                                           (wrap-27923
+                                             (let ((w2-27931
+                                                     (vector-ref x-27890 2)))
+                                               (let ((m1-27932 (car w-26979))
+                                                     (s1-27933 (cdr w-26979)))
+                                                 (if (null? m1-27932)
+                                                   (if (null? s1-27933)
+                                                     w2-27931
+                                                     (cons (car w2-27931)
+                                                           (let ((m2-27948
+                                                                   (cdr 
w2-27931)))
+                                                             (if (null? 
m2-27948)
+                                                               s1-27933
                                                                (append
-                                                                 s1-27747
-                                                                 m2-27762)))))
-                                                   (cons (let ((m2-27770
-                                                                 (car 
w2-27745)))
-                                                           (if (null? m2-27770)
-                                                             m1-27746
+                                                                 s1-27933
+                                                                 m2-27948)))))
+                                                   (cons (let ((m2-27956
+                                                                 (car 
w2-27931)))
+                                                           (if (null? m2-27956)
+                                                             m1-27932
                                                              (append
-                                                               m1-27746
-                                                               m2-27770)))
-                                                         (let ((m2-27778
-                                                                 (cdr 
w2-27745)))
-                                                           (if (null? m2-27778)
-                                                             s1-27747
+                                                               m1-27932
+                                                               m2-27956)))
+                                                         (let ((m2-27964
+                                                                 (cdr 
w2-27931)))
+                                                           (if (null? m2-27964)
+                                                             s1-27933
                                                              (append
-                                                               s1-27747
-                                                               m2-27778))))))))
-                                           (module-27738
-                                             (vector-ref x-27704 3)))
+                                                               s1-27933
+                                                               m2-27964))))))))
+                                           (module-27924
+                                             (vector-ref x-27890 3)))
                                        (vector
                                          'syntax-object
-                                         expression-27736
-                                         wrap-27737
-                                         module-27738))
-                                     (if (null? x-27704)
-                                       x-27704
+                                         expression-27922
+                                         wrap-27923
+                                         module-27924))
+                                     (if (null? x-27890)
+                                       x-27890
                                        (vector
                                          'syntax-object
-                                         x-27704
-                                         w-26812
-                                         mod-26814)))))
+                                         x-27890
+                                         w-26979
+                                         mod-26981)))))
                                '(()))))
                        (make-struct/no-tail
                          (vector-ref %expanded-vtables 1)
-                         s-26813
-                         exp-27691))
-                     (if (eqv? type-26807 'global)
-                       (analyze-variable-4522
-                         mod-26814
-                         value-26808
-                         (lambda (mod-27803 var-27804 public?-27805)
+                         s-26980
+                         exp-27877))
+                     (if (eqv? type-26974 'global)
+                       (analyze-variable-4318
+                         mod-26981
+                         value-26975
+                         (lambda (mod-27992 var-27993 public?-27994)
                            (make-struct/no-tail
                              (vector-ref %expanded-vtables 5)
-                             s-26813
-                             mod-27803
-                             var-27804
-                             public?-27805))
-                         (lambda (var-27813)
+                             s-26980
+                             mod-27992
+                             var-27993
+                             public?-27994))
+                         (lambda (var-28002)
                            (make-struct/no-tail
                              (vector-ref %expanded-vtables 7)
-                             s-26813
-                             var-27813)))
-                       (if (eqv? type-26807 'call)
-                         (expand-call-4588
-                           (expand-4586
-                             (car e-26810)
-                             r-26811
-                             w-26812
-                             mod-26814)
-                           e-26810
-                           r-26811
-                           w-26812
-                           s-26813
-                           mod-26814)
-                         (if (eqv? type-26807 'begin-form)
-                           (let ((tmp-27983
-                                   ($sc-dispatch e-26810 '(_ any . each-any))))
-                             (if tmp-27983
+                             s-26980
+                             var-28002)))
+                       (if (eqv? type-26974 'call)
+                         (expand-call-4384
+                           (expand-4382
+                             (car e-26977)
+                             r-26978
+                             w-26979
+                             mod-26981)
+                           e-26977
+                           r-26978
+                           w-26979
+                           s-26980
+                           mod-26981)
+                         (if (eqv? type-26974 'begin-form)
+                           (let ((tmp-28178
+                                   ($sc-dispatch e-26977 '(_ any . each-any))))
+                             (if tmp-28178
                                (@apply
-                                 (lambda (e1-27987 e2-27988)
-                                   (expand-sequence-4581
-                                     (cons e1-27987 e2-27988)
-                                     r-26811
-                                     w-26812
-                                     s-26813
-                                     mod-26814))
-                                 tmp-27983)
-                               (let ((tmp-28083 ($sc-dispatch e-26810 '(_))))
-                                 (if tmp-28083
+                                 (lambda (e1-28182 e2-28183)
+                                   (expand-sequence-4377
+                                     (cons e1-28182 e2-28183)
+                                     r-26978
+                                     w-26979
+                                     s-26980
+                                     mod-26981))
+                                 tmp-28178)
+                               (let ((tmp-28278 ($sc-dispatch e-26977 '(_))))
+                                 (if tmp-28278
                                    (@apply
                                      (lambda ()
                                        (syntax-violation
                                          #f
                                          "sequence of zero expressions"
-                                         (let ((x-28096
+                                         (let ((x-28291
                                                  (begin
-                                                   (if (if (pair? e-26810)
-                                                         s-26813
+                                                   (if (if (pair? e-26977)
+                                                         s-26980
                                                          #f)
                                                      (set-source-properties!
-                                                       e-26810
-                                                       s-26813))
-                                                   e-26810)))
-                                           (if (if (null? (car w-26812))
-                                                 (null? (cdr w-26812))
+                                                       e-26977
+                                                       s-26980))
+                                                   e-26977)))
+                                           (if (if (null? (car w-26979))
+                                                 (null? (cdr w-26979))
                                                  #f)
-                                             x-28096
-                                             (if (if (vector? x-28096)
+                                             x-28291
+                                             (if (if (vector? x-28291)
                                                    (if (= (vector-length
-                                                            x-28096)
+                                                            x-28291)
                                                           4)
                                                      (eq? (vector-ref
-                                                            x-28096
+                                                            x-28291
                                                             0)
                                                           'syntax-object)
                                                      #f)
                                                    #f)
-                                               (let ((expression-28128
-                                                       (vector-ref x-28096 1))
-                                                     (wrap-28129
-                                                       (let ((w2-28137
+                                               (let ((expression-28323
+                                                       (vector-ref x-28291 1))
+                                                     (wrap-28324
+                                                       (let ((w2-28332
                                                                (vector-ref
-                                                                 x-28096
+                                                                 x-28291
                                                                  2)))
-                                                         (let ((m1-28138
-                                                                 (car w-26812))
-                                                               (s1-28139
-                                                                 (cdr 
w-26812)))
-                                                           (if (null? m1-28138)
-                                                             (if (null? 
s1-28139)
-                                                               w2-28137
-                                                               (cons (car 
w2-28137)
-                                                                     (let 
((m2-28154
-                                                                             
(cdr w2-28137)))
-                                                                       (if 
(null? m2-28154)
-                                                                         
s1-28139
+                                                         (let ((m1-28333
+                                                                 (car w-26979))
+                                                               (s1-28334
+                                                                 (cdr 
w-26979)))
+                                                           (if (null? m1-28333)
+                                                             (if (null? 
s1-28334)
+                                                               w2-28332
+                                                               (cons (car 
w2-28332)
+                                                                     (let 
((m2-28349
+                                                                             
(cdr w2-28332)))
+                                                                       (if 
(null? m2-28349)
+                                                                         
s1-28334
                                                                          
(append
-                                                                           
s1-28139
-                                                                           
m2-28154)))))
-                                                             (cons (let 
((m2-28162
-                                                                           
(car w2-28137)))
-                                                                     (if 
(null? m2-28162)
-                                                                       m1-28138
+                                                                           
s1-28334
+                                                                           
m2-28349)))))
+                                                             (cons (let 
((m2-28357
+                                                                           
(car w2-28332)))
+                                                                     (if 
(null? m2-28357)
+                                                                       m1-28333
                                                                        (append
-                                                                         
m1-28138
-                                                                         
m2-28162)))
-                                                                   (let 
((m2-28170
-                                                                           
(cdr w2-28137)))
-                                                                     (if 
(null? m2-28170)
-                                                                       s1-28139
+                                                                         
m1-28333
+                                                                         
m2-28357)))
+                                                                   (let 
((m2-28365
+                                                                           
(cdr w2-28332)))
+                                                                     (if 
(null? m2-28365)
+                                                                       s1-28334
                                                                        (append
-                                                                         
s1-28139
-                                                                         
m2-28170))))))))
-                                                     (module-28130
-                                                       (vector-ref x-28096 3)))
+                                                                         
s1-28334
+                                                                         
m2-28365))))))))
+                                                     (module-28325
+                                                       (vector-ref x-28291 3)))
                                                  (vector
                                                    'syntax-object
-                                                   expression-28128
-                                                   wrap-28129
-                                                   module-28130))
-                                               (if (null? x-28096)
-                                                 x-28096
+                                                   expression-28323
+                                                   wrap-28324
+                                                   module-28325))
+                                               (if (null? x-28291)
+                                                 x-28291
                                                  (vector
                                                    'syntax-object
-                                                   x-28096
-                                                   w-26812
-                                                   mod-26814)))))))
-                                     tmp-28083)
+                                                   x-28291
+                                                   w-26979
+                                                   mod-26981)))))))
+                                     tmp-28278)
                                    (syntax-violation
                                      #f
                                      "source expression failed to match any 
pattern"
-                                     e-26810)))))
-                           (if (eqv? type-26807 'local-syntax-form)
-                             (expand-local-syntax-4591
-                               value-26808
-                               e-26810
-                               r-26811
-                               w-26812
-                               s-26813
-                               mod-26814
-                               expand-sequence-4581)
-                             (if (eqv? type-26807 'eval-when-form)
-                               (let ((tmp-28265
+                                     e-26977)))))
+                           (if (eqv? type-26974 'local-syntax-form)
+                             (expand-local-syntax-4387
+                               value-26975
+                               e-26977
+                               r-26978
+                               w-26979
+                               s-26980
+                               mod-26981
+                               expand-sequence-4377)
+                             (if (eqv? type-26974 'eval-when-form)
+                               (let ((tmp-28466
                                        ($sc-dispatch
-                                         e-26810
+                                         e-26977
                                          '(_ each-any any . each-any))))
-                                 (if tmp-28265
+                                 (if tmp-28466
                                    (@apply
-                                     (lambda (x-28269 e1-28270 e2-28271)
-                                       (let ((when-list-28272
-                                               (parse-when-list-4584
-                                                 e-26810
-                                                 x-28269)))
-                                         (if (memq 'eval when-list-28272)
-                                           (expand-sequence-4581
-                                             (cons e1-28270 e2-28271)
-                                             r-26811
-                                             w-26812
-                                             s-26813
-                                             mod-26814)
+                                     (lambda (x-28470 e1-28471 e2-28472)
+                                       (let ((when-list-28473
+                                               (parse-when-list-4380
+                                                 e-26977
+                                                 x-28470)))
+                                         (if (memq 'eval when-list-28473)
+                                           (expand-sequence-4377
+                                             (cons e1-28471 e2-28472)
+                                             r-26978
+                                             w-26979
+                                             s-26980
+                                             mod-26981)
                                            (make-struct/no-tail
                                              (vector-ref %expanded-vtables 0)
                                              #f))))
-                                     tmp-28265)
+                                     tmp-28466)
                                    (syntax-violation
                                      #f
                                      "source expression failed to match any 
pattern"
-                                     e-26810)))
-                               (if (if (eqv? type-26807 'define-form)
+                                     e-26977)))
+                               (if (if (eqv? type-26974 'define-form)
                                      #t
-                                     (if (eqv? type-26807 'define-syntax-form)
+                                     (if (eqv? type-26974 'define-syntax-form)
                                        #t
-                                       (eqv? type-26807
+                                       (eqv? type-26974
                                              'define-syntax-parameter-form)))
                                  (syntax-violation
                                    #f
                                    "definition in expression context, where 
definitions are not allowed,"
-                                   (let ((x-28458
+                                   (let ((x-28662
                                            (begin
-                                             (if (if (pair? form-26809)
-                                                   s-26813
+                                             (if (if (pair? form-26976)
+                                                   s-26980
                                                    #f)
                                                (set-source-properties!
-                                                 form-26809
-                                                 s-26813))
-                                             form-26809)))
-                                     (if (if (null? (car w-26812))
-                                           (null? (cdr w-26812))
+                                                 form-26976
+                                                 s-26980))
+                                             form-26976)))
+                                     (if (if (null? (car w-26979))
+                                           (null? (cdr w-26979))
                                            #f)
-                                       x-28458
-                                       (if (if (vector? x-28458)
-                                             (if (= (vector-length x-28458) 4)
-                                               (eq? (vector-ref x-28458 0)
+                                       x-28662
+                                       (if (if (vector? x-28662)
+                                             (if (= (vector-length x-28662) 4)
+                                               (eq? (vector-ref x-28662 0)
                                                     'syntax-object)
                                                #f)
                                              #f)
-                                         (let ((expression-28490
-                                                 (vector-ref x-28458 1))
-                                               (wrap-28491
-                                                 (let ((w2-28499
+                                         (let ((expression-28694
+                                                 (vector-ref x-28662 1))
+                                               (wrap-28695
+                                                 (let ((w2-28703
                                                          (vector-ref
-                                                           x-28458
+                                                           x-28662
                                                            2)))
-                                                   (let ((m1-28500
-                                                           (car w-26812))
-                                                         (s1-28501
-                                                           (cdr w-26812)))
-                                                     (if (null? m1-28500)
-                                                       (if (null? s1-28501)
-                                                         w2-28499
-                                                         (cons (car w2-28499)
-                                                               (let ((m2-28516
-                                                                       (cdr 
w2-28499)))
-                                                                 (if (null? 
m2-28516)
-                                                                   s1-28501
+                                                   (let ((m1-28704
+                                                           (car w-26979))
+                                                         (s1-28705
+                                                           (cdr w-26979)))
+                                                     (if (null? m1-28704)
+                                                       (if (null? s1-28705)
+                                                         w2-28703
+                                                         (cons (car w2-28703)
+                                                               (let ((m2-28720
+                                                                       (cdr 
w2-28703)))
+                                                                 (if (null? 
m2-28720)
+                                                                   s1-28705
                                                                    (append
-                                                                     s1-28501
-                                                                     
m2-28516)))))
-                                                       (cons (let ((m2-28524
-                                                                     (car 
w2-28499)))
-                                                               (if (null? 
m2-28524)
-                                                                 m1-28500
+                                                                     s1-28705
+                                                                     
m2-28720)))))
+                                                       (cons (let ((m2-28728
+                                                                     (car 
w2-28703)))
+                                                               (if (null? 
m2-28728)
+                                                                 m1-28704
                                                                  (append
-                                                                   m1-28500
-                                                                   m2-28524)))
-                                                             (let ((m2-28532
-                                                                     (cdr 
w2-28499)))
-                                                               (if (null? 
m2-28532)
-                                                                 s1-28501
+                                                                   m1-28704
+                                                                   m2-28728)))
+                                                             (let ((m2-28736
+                                                                     (cdr 
w2-28703)))
+                                                               (if (null? 
m2-28736)
+                                                                 s1-28705
                                                                  (append
-                                                                   s1-28501
-                                                                   
m2-28532))))))))
-                                               (module-28492
-                                                 (vector-ref x-28458 3)))
+                                                                   s1-28705
+                                                                   
m2-28736))))))))
+                                               (module-28696
+                                                 (vector-ref x-28662 3)))
                                            (vector
                                              'syntax-object
-                                             expression-28490
-                                             wrap-28491
-                                             module-28492))
-                                         (if (null? x-28458)
-                                           x-28458
+                                             expression-28694
+                                             wrap-28695
+                                             module-28696))
+                                         (if (null? x-28662)
+                                           x-28662
                                            (vector
                                              'syntax-object
-                                             x-28458
-                                             w-26812
-                                             mod-26814))))))
-                                 (if (eqv? type-26807 'syntax)
+                                             x-28662
+                                             w-26979
+                                             mod-26981))))))
+                                 (if (eqv? type-26974 'syntax)
                                    (syntax-violation
                                      #f
                                      "reference to pattern variable outside 
syntax form"
-                                     (let ((x-28559
+                                     (let ((x-28766
                                              (begin
-                                               (if (if (pair? e-26810)
-                                                     s-26813
+                                               (if (if (pair? e-26977)
+                                                     s-26980
                                                      #f)
                                                  (set-source-properties!
-                                                   e-26810
-                                                   s-26813))
-                                               e-26810)))
-                                       (if (if (null? (car w-26812))
-                                             (null? (cdr w-26812))
+                                                   e-26977
+                                                   s-26980))
+                                               e-26977)))
+                                       (if (if (null? (car w-26979))
+                                             (null? (cdr w-26979))
                                              #f)
-                                         x-28559
-                                         (if (if (vector? x-28559)
-                                               (if (= (vector-length x-28559)
+                                         x-28766
+                                         (if (if (vector? x-28766)
+                                               (if (= (vector-length x-28766)
                                                       4)
-                                                 (eq? (vector-ref x-28559 0)
+                                                 (eq? (vector-ref x-28766 0)
                                                       'syntax-object)
                                                  #f)
                                                #f)
-                                           (let ((expression-28591
-                                                   (vector-ref x-28559 1))
-                                                 (wrap-28592
-                                                   (let ((w2-28600
+                                           (let ((expression-28798
+                                                   (vector-ref x-28766 1))
+                                                 (wrap-28799
+                                                   (let ((w2-28807
                                                            (vector-ref
-                                                             x-28559
+                                                             x-28766
                                                              2)))
-                                                     (let ((m1-28601
-                                                             (car w-26812))
-                                                           (s1-28602
-                                                             (cdr w-26812)))
-                                                       (if (null? m1-28601)
-                                                         (if (null? s1-28602)
-                                                           w2-28600
-                                                           (cons (car w2-28600)
-                                                                 (let 
((m2-28617
-                                                                         (cdr 
w2-28600)))
-                                                                   (if (null? 
m2-28617)
-                                                                     s1-28602
+                                                     (let ((m1-28808
+                                                             (car w-26979))
+                                                           (s1-28809
+                                                             (cdr w-26979)))
+                                                       (if (null? m1-28808)
+                                                         (if (null? s1-28809)
+                                                           w2-28807
+                                                           (cons (car w2-28807)
+                                                                 (let 
((m2-28824
+                                                                         (cdr 
w2-28807)))
+                                                                   (if (null? 
m2-28824)
+                                                                     s1-28809
                                                                      (append
-                                                                       s1-28602
-                                                                       
m2-28617)))))
-                                                         (cons (let ((m2-28625
-                                                                       (car 
w2-28600)))
-                                                                 (if (null? 
m2-28625)
-                                                                   m1-28601
+                                                                       s1-28809
+                                                                       
m2-28824)))))
+                                                         (cons (let ((m2-28832
+                                                                       (car 
w2-28807)))
+                                                                 (if (null? 
m2-28832)
+                                                                   m1-28808
                                                                    (append
-                                                                     m1-28601
-                                                                     
m2-28625)))
-                                                               (let ((m2-28633
-                                                                       (cdr 
w2-28600)))
-                                                                 (if (null? 
m2-28633)
-                                                                   s1-28602
+                                                                     m1-28808
+                                                                     
m2-28832)))
+                                                               (let ((m2-28840
+                                                                       (cdr 
w2-28807)))
+                                                                 (if (null? 
m2-28840)
+                                                                   s1-28809
                                                                    (append
-                                                                     s1-28602
-                                                                     
m2-28633))))))))
-                                                 (module-28593
-                                                   (vector-ref x-28559 3)))
+                                                                     s1-28809
+                                                                     
m2-28840))))))))
+                                                 (module-28800
+                                                   (vector-ref x-28766 3)))
                                              (vector
                                                'syntax-object
-                                               expression-28591
-                                               wrap-28592
-                                               module-28593))
-                                           (if (null? x-28559)
-                                             x-28559
+                                               expression-28798
+                                               wrap-28799
+                                               module-28800))
+                                           (if (null? x-28766)
+                                             x-28766
                                              (vector
                                                'syntax-object
-                                               x-28559
-                                               w-26812
-                                               mod-26814))))))
-                                   (if (eqv? type-26807 'displaced-lexical)
+                                               x-28766
+                                               w-26979
+                                               mod-26981))))))
+                                   (if (eqv? type-26974 'displaced-lexical)
                                      (syntax-violation
                                        #f
                                        "reference to identifier outside its 
scope"
-                                       (let ((x-28660
+                                       (let ((x-28870
                                                (begin
-                                                 (if (if (pair? e-26810)
-                                                       s-26813
+                                                 (if (if (pair? e-26977)
+                                                       s-26980
                                                        #f)
                                                    (set-source-properties!
-                                                     e-26810
-                                                     s-26813))
-                                                 e-26810)))
-                                         (if (if (null? (car w-26812))
-                                               (null? (cdr w-26812))
+                                                     e-26977
+                                                     s-26980))
+                                                 e-26977)))
+                                         (if (if (null? (car w-26979))
+                                               (null? (cdr w-26979))
                                                #f)
-                                           x-28660
-                                           (if (if (vector? x-28660)
-                                                 (if (= (vector-length x-28660)
+                                           x-28870
+                                           (if (if (vector? x-28870)
+                                                 (if (= (vector-length x-28870)
                                                         4)
-                                                   (eq? (vector-ref x-28660 0)
+                                                   (eq? (vector-ref x-28870 0)
                                                         'syntax-object)
                                                    #f)
                                                  #f)
-                                             (let ((expression-28692
-                                                     (vector-ref x-28660 1))
-                                                   (wrap-28693
-                                                     (let ((w2-28701
+                                             (let ((expression-28902
+                                                     (vector-ref x-28870 1))
+                                                   (wrap-28903
+                                                     (let ((w2-28911
                                                              (vector-ref
-                                                               x-28660
+                                                               x-28870
                                                                2)))
-                                                       (let ((m1-28702
-                                                               (car w-26812))
-                                                             (s1-28703
-                                                               (cdr w-26812)))
-                                                         (if (null? m1-28702)
-                                                           (if (null? s1-28703)
-                                                             w2-28701
-                                                             (cons (car 
w2-28701)
-                                                                   (let 
((m2-28718
-                                                                           
(cdr w2-28701)))
-                                                                     (if 
(null? m2-28718)
-                                                                       s1-28703
+                                                       (let ((m1-28912
+                                                               (car w-26979))
+                                                             (s1-28913
+                                                               (cdr w-26979)))
+                                                         (if (null? m1-28912)
+                                                           (if (null? s1-28913)
+                                                             w2-28911
+                                                             (cons (car 
w2-28911)
+                                                                   (let 
((m2-28928
+                                                                           
(cdr w2-28911)))
+                                                                     (if 
(null? m2-28928)
+                                                                       s1-28913
                                                                        (append
-                                                                         
s1-28703
-                                                                         
m2-28718)))))
-                                                           (cons (let 
((m2-28726
-                                                                         (car 
w2-28701)))
-                                                                   (if (null? 
m2-28726)
-                                                                     m1-28702
+                                                                         
s1-28913
+                                                                         
m2-28928)))))
+                                                           (cons (let 
((m2-28936
+                                                                         (car 
w2-28911)))
+                                                                   (if (null? 
m2-28936)
+                                                                     m1-28912
                                                                      (append
-                                                                       m1-28702
-                                                                       
m2-28726)))
-                                                                 (let 
((m2-28734
-                                                                         (cdr 
w2-28701)))
-                                                                   (if (null? 
m2-28734)
-                                                                     s1-28703
+                                                                       m1-28912
+                                                                       
m2-28936)))
+                                                                 (let 
((m2-28944
+                                                                         (cdr 
w2-28911)))
+                                                                   (if (null? 
m2-28944)
+                                                                     s1-28913
                                                                      (append
-                                                                       s1-28703
-                                                                       
m2-28734))))))))
-                                                   (module-28694
-                                                     (vector-ref x-28660 3)))
+                                                                       s1-28913
+                                                                       
m2-28944))))))))
+                                                   (module-28904
+                                                     (vector-ref x-28870 3)))
                                                (vector
                                                  'syntax-object
-                                                 expression-28692
-                                                 wrap-28693
-                                                 module-28694))
-                                             (if (null? x-28660)
-                                               x-28660
+                                                 expression-28902
+                                                 wrap-28903
+                                                 module-28904))
+                                             (if (null? x-28870)
+                                               x-28870
                                                (vector
                                                  'syntax-object
-                                                 x-28660
-                                                 w-26812
-                                                 mod-26814))))))
+                                                 x-28870
+                                                 w-26979
+                                                 mod-26981))))))
                                      (syntax-violation
                                        #f
                                        "unexpected syntax"
-                                       (let ((x-28758
+                                       (let ((x-28968
                                                (begin
-                                                 (if (if (pair? e-26810)
-                                                       s-26813
+                                                 (if (if (pair? e-26977)
+                                                       s-26980
                                                        #f)
                                                    (set-source-properties!
-                                                     e-26810
-                                                     s-26813))
-                                                 e-26810)))
-                                         (if (if (null? (car w-26812))
-                                               (null? (cdr w-26812))
+                                                     e-26977
+                                                     s-26980))
+                                                 e-26977)))
+                                         (if (if (null? (car w-26979))
+                                               (null? (cdr w-26979))
                                                #f)
-                                           x-28758
-                                           (if (if (vector? x-28758)
-                                                 (if (= (vector-length x-28758)
+                                           x-28968
+                                           (if (if (vector? x-28968)
+                                                 (if (= (vector-length x-28968)
                                                         4)
-                                                   (eq? (vector-ref x-28758 0)
+                                                   (eq? (vector-ref x-28968 0)
                                                         'syntax-object)
                                                    #f)
                                                  #f)
-                                             (let ((expression-28790
-                                                     (vector-ref x-28758 1))
-                                                   (wrap-28791
-                                                     (let ((w2-28799
+                                             (let ((expression-29000
+                                                     (vector-ref x-28968 1))
+                                                   (wrap-29001
+                                                     (let ((w2-29009
                                                              (vector-ref
-                                                               x-28758
+                                                               x-28968
                                                                2)))
-                                                       (let ((m1-28800
-                                                               (car w-26812))
-                                                             (s1-28801
-                                                               (cdr w-26812)))
-                                                         (if (null? m1-28800)
-                                                           (if (null? s1-28801)
-                                                             w2-28799
-                                                             (cons (car 
w2-28799)
-                                                                   (let 
((m2-28816
-                                                                           
(cdr w2-28799)))
-                                                                     (if 
(null? m2-28816)
-                                                                       s1-28801
+                                                       (let ((m1-29010
+                                                               (car w-26979))
+                                                             (s1-29011
+                                                               (cdr w-26979)))
+                                                         (if (null? m1-29010)
+                                                           (if (null? s1-29011)
+                                                             w2-29009
+                                                             (cons (car 
w2-29009)
+                                                                   (let 
((m2-29026
+                                                                           
(cdr w2-29009)))
+                                                                     (if 
(null? m2-29026)
+                                                                       s1-29011
                                                                        (append
-                                                                         
s1-28801
-                                                                         
m2-28816)))))
-                                                           (cons (let 
((m2-28824
-                                                                         (car 
w2-28799)))
-                                                                   (if (null? 
m2-28824)
-                                                                     m1-28800
+                                                                         
s1-29011
+                                                                         
m2-29026)))))
+                                                           (cons (let 
((m2-29034
+                                                                         (car 
w2-29009)))
+                                                                   (if (null? 
m2-29034)
+                                                                     m1-29010
                                                                      (append
-                                                                       m1-28800
-                                                                       
m2-28824)))
-                                                                 (let 
((m2-28832
-                                                                         (cdr 
w2-28799)))
-                                                                   (if (null? 
m2-28832)
-                                                                     s1-28801
+                                                                       m1-29010
+                                                                       
m2-29034)))
+                                                                 (let 
((m2-29042
+                                                                         (cdr 
w2-29009)))
+                                                                   (if (null? 
m2-29042)
+                                                                     s1-29011
                                                                      (append
-                                                                       s1-28801
-                                                                       
m2-28832))))))))
-                                                   (module-28792
-                                                     (vector-ref x-28758 3)))
+                                                                       s1-29011
+                                                                       
m2-29042))))))))
+                                                   (module-29002
+                                                     (vector-ref x-28968 3)))
                                                (vector
                                                  'syntax-object
-                                                 expression-28790
-                                                 wrap-28791
-                                                 module-28792))
-                                             (if (null? x-28758)
-                                               x-28758
+                                                 expression-29000
+                                                 wrap-29001
+                                                 module-29002))
+                                             (if (null? x-28968)
+                                               x-28968
                                                (vector
                                                  'syntax-object
-                                                 x-28758
-                                                 w-26812
-                                                 
mod-26814))))))))))))))))))))))
-     (expand-call-4588
-       (lambda (x-28847
-                e-28848
-                r-28849
-                w-28850
-                s-28851
-                mod-28852)
-         (let ((tmp-28854
-                 ($sc-dispatch e-28848 '(any . each-any))))
-           (if tmp-28854
+                                                 x-28968
+                                                 w-26979
+                                                 
mod-26981))))))))))))))))))))))
+     (expand-call-4384
+       (lambda (x-29057
+                e-29058
+                r-29059
+                w-29060
+                s-29061
+                mod-29062)
+         (let ((tmp-29064
+                 ($sc-dispatch e-29058 '(any . each-any))))
+           (if tmp-29064
              (@apply
-               (lambda (e0-28858 e1-28859)
-                 (build-call-4517
-                   s-28851
-                   x-28847
-                   (map (lambda (e-28947)
-                          (expand-4586 e-28947 r-28849 w-28850 mod-28852))
-                        e1-28859)))
-               tmp-28854)
+               (lambda (e0-29068 e1-29069)
+                 (build-call-4313
+                   s-29061
+                   x-29057
+                   (map (lambda (e-29157)
+                          (expand-4382 e-29157 r-29059 w-29060 mod-29062))
+                        e1-29069)))
+               tmp-29064)
              (syntax-violation
                #f
                "source expression failed to match any pattern"
-               e-28848)))))
-     (expand-macro-4589
-       (lambda (p-29031
-                e-29032
-                r-29033
-                w-29034
-                s-29035
-                rib-29036
-                mod-29037)
+               e-29058)))))
+     (expand-macro-4385
+       (lambda (p-29241
+                e-29242
+                r-29243
+                w-29244
+                s-29245
+                rib-29246
+                mod-29247)
          (letrec*
-           ((rebuild-macro-output-29038
-              (lambda (x-29147 m-29148)
-                (if (pair? x-29147)
-                  (let ((e-29152
-                          (cons (rebuild-macro-output-29038
-                                  (car x-29147)
-                                  m-29148)
-                                (rebuild-macro-output-29038
-                                  (cdr x-29147)
-                                  m-29148))))
+           ((rebuild-macro-output-29248
+              (lambda (x-29357 m-29358)
+                (if (pair? x-29357)
+                  (let ((e-29362
+                          (cons (rebuild-macro-output-29248
+                                  (car x-29357)
+                                  m-29358)
+                                (rebuild-macro-output-29248
+                                  (cdr x-29357)
+                                  m-29358))))
                     (begin
-                      (if (if (pair? e-29152) s-29035 #f)
-                        (set-source-properties! e-29152 s-29035))
-                      e-29152))
-                  (if (if (vector? x-29147)
-                        (if (= (vector-length x-29147) 4)
-                          (eq? (vector-ref x-29147 0) 'syntax-object)
+                      (if (if (pair? e-29362) s-29245 #f)
+                        (set-source-properties! e-29362 s-29245))
+                      e-29362))
+                  (if (if (vector? x-29357)
+                        (if (= (vector-length x-29357) 4)
+                          (eq? (vector-ref x-29357 0) 'syntax-object)
                           #f)
                         #f)
-                    (let ((w-29168 (vector-ref x-29147 2)))
-                      (let ((ms-29169 (car w-29168))
-                            (s-29170 (cdr w-29168)))
-                        (if (if (pair? ms-29169) (eq? (car ms-29169) #f) #f)
-                          (let ((expression-29178 (vector-ref x-29147 1))
-                                (wrap-29179
-                                  (cons (cdr ms-29169)
-                                        (if rib-29036
-                                          (cons rib-29036 (cdr s-29170))
-                                          (cdr s-29170))))
-                                (module-29180 (vector-ref x-29147 3)))
+                    (let ((w-29378 (vector-ref x-29357 2)))
+                      (let ((ms-29379 (car w-29378))
+                            (ss-29380 (cdr w-29378)))
+                        (if (if (pair? ms-29379) (eq? (car ms-29379) #f) #f)
+                          (let ((expression-29388 (vector-ref x-29357 1))
+                                (wrap-29389
+                                  (cons (cdr ms-29379)
+                                        (if rib-29246
+                                          (cons rib-29246 (cdr ss-29380))
+                                          (cdr ss-29380))))
+                                (module-29390 (vector-ref x-29357 3)))
                             (vector
                               'syntax-object
-                              expression-29178
-                              wrap-29179
-                              module-29180))
-                          (let ((expression-29190
-                                  (let ((e-29195 (vector-ref x-29147 1)))
+                              expression-29388
+                              wrap-29389
+                              module-29390))
+                          (let ((expression-29400
+                                  (let ((e-29405 (vector-ref x-29357 1)))
                                     (begin
-                                      (if (if (pair? e-29195) s-29170 #f)
+                                      (if (if (pair? e-29405) s-29245 #f)
                                         (set-source-properties!
-                                          e-29195
-                                          s-29170))
-                                      e-29195)))
-                                (wrap-29191
-                                  (cons (cons m-29148 ms-29169)
-                                        (if rib-29036
-                                          (cons rib-29036
-                                                (cons 'shift s-29170))
-                                          (cons 'shift s-29170))))
-                                (module-29192 (vector-ref x-29147 3)))
+                                          e-29405
+                                          s-29245))
+                                      e-29405)))
+                                (wrap-29401
+                                  (cons (cons m-29358 ms-29379)
+                                        (if rib-29246
+                                          (cons rib-29246
+                                                (cons 'shift ss-29380))
+                                          (cons 'shift ss-29380))))
+                                (module-29402 (vector-ref x-29357 3)))
                             (vector
                               'syntax-object
-                              expression-29190
-                              wrap-29191
-                              module-29192)))))
-                    (if (vector? x-29147)
-                      (let ((n-29207 (vector-length x-29147)))
-                        (let ((v-29208
-                                (let ((e-29274 (make-vector n-29207)))
+                              expression-29400
+                              wrap-29401
+                              module-29402)))))
+                    (if (vector? x-29357)
+                      (let ((n-29417 (vector-length x-29357)))
+                        (let ((v-29418
+                                (let ((e-29484 (make-vector n-29417)))
                                   (begin
-                                    (if (if (pair? e-29274) x-29147 #f)
-                                      (set-source-properties! e-29274 x-29147))
-                                    e-29274))))
+                                    (if (if (pair? e-29484) s-29245 #f)
+                                      (set-source-properties! e-29484 s-29245))
+                                    e-29484))))
                           (letrec*
-                            ((loop-29209
-                               (lambda (i-29270)
-                                 (if (= i-29270 n-29207)
-                                   v-29208
+                            ((loop-29419
+                               (lambda (i-29480)
+                                 (if (= i-29480 n-29417)
+                                   v-29418
                                    (begin
                                      (vector-set!
-                                       v-29208
-                                       i-29270
-                                       (rebuild-macro-output-29038
-                                         (vector-ref x-29147 i-29270)
-                                         m-29148))
-                                     (loop-29209 (#{1+}# i-29270)))))))
-                            (loop-29209 0))))
-                      (if (symbol? x-29147)
+                                       v-29418
+                                       i-29480
+                                       (rebuild-macro-output-29248
+                                         (vector-ref x-29357 i-29480)
+                                         m-29358))
+                                     (loop-29419 (#{1+}# i-29480)))))))
+                            (loop-29419 0))))
+                      (if (symbol? x-29357)
                         (syntax-violation
                           #f
                           "encountered raw symbol in macro output"
-                          (let ((s-29285 (cdr w-29034)))
-                            (let ((x-29289
+                          (let ((s-29495 (cdr w-29244)))
+                            (let ((x-29499
                                     (begin
-                                      (if (if (pair? e-29032) s-29285 #f)
+                                      (if (if (pair? e-29242) s-29495 #f)
                                         (set-source-properties!
-                                          e-29032
-                                          s-29285))
-                                      e-29032)))
-                              (if (if (null? (car w-29034))
-                                    (null? (cdr w-29034))
+                                          e-29242
+                                          s-29495))
+                                      e-29242)))
+                              (if (if (null? (car w-29244))
+                                    (null? (cdr w-29244))
                                     #f)
-                                x-29289
-                                (if (if (vector? x-29289)
-                                      (if (= (vector-length x-29289) 4)
-                                        (eq? (vector-ref x-29289 0)
+                                x-29499
+                                (if (if (vector? x-29499)
+                                      (if (= (vector-length x-29499) 4)
+                                        (eq? (vector-ref x-29499 0)
                                              'syntax-object)
                                         #f)
                                       #f)
-                                  (let ((expression-29321
-                                          (vector-ref x-29289 1))
-                                        (wrap-29322
-                                          (let ((w2-29330
-                                                  (vector-ref x-29289 2)))
-                                            (let ((m1-29331 (car w-29034))
-                                                  (s1-29332 (cdr w-29034)))
-                                              (if (null? m1-29331)
-                                                (if (null? s1-29332)
-                                                  w2-29330
-                                                  (cons (car w2-29330)
-                                                        (let ((m2-29347
-                                                                (cdr 
w2-29330)))
-                                                          (if (null? m2-29347)
-                                                            s1-29332
+                                  (let ((expression-29531
+                                          (vector-ref x-29499 1))
+                                        (wrap-29532
+                                          (let ((w2-29540
+                                                  (vector-ref x-29499 2)))
+                                            (let ((m1-29541 (car w-29244))
+                                                  (s1-29542 (cdr w-29244)))
+                                              (if (null? m1-29541)
+                                                (if (null? s1-29542)
+                                                  w2-29540
+                                                  (cons (car w2-29540)
+                                                        (let ((m2-29557
+                                                                (cdr 
w2-29540)))
+                                                          (if (null? m2-29557)
+                                                            s1-29542
                                                             (append
-                                                              s1-29332
-                                                              m2-29347)))))
-                                                (cons (let ((m2-29355
-                                                              (car w2-29330)))
-                                                        (if (null? m2-29355)
-                                                          m1-29331
+                                                              s1-29542
+                                                              m2-29557)))))
+                                                (cons (let ((m2-29565
+                                                              (car w2-29540)))
+                                                        (if (null? m2-29565)
+                                                          m1-29541
                                                           (append
-                                                            m1-29331
-                                                            m2-29355)))
-                                                      (let ((m2-29363
-                                                              (cdr w2-29330)))
-                                                        (if (null? m2-29363)
-                                                          s1-29332
+                                                            m1-29541
+                                                            m2-29565)))
+                                                      (let ((m2-29573
+                                                              (cdr w2-29540)))
+                                                        (if (null? m2-29573)
+                                                          s1-29542
                                                           (append
-                                                            s1-29332
-                                                            m2-29363))))))))
-                                        (module-29323 (vector-ref x-29289 3)))
+                                                            s1-29542
+                                                            m2-29573))))))))
+                                        (module-29533 (vector-ref x-29499 3)))
                                     (vector
                                       'syntax-object
-                                      expression-29321
-                                      wrap-29322
-                                      module-29323))
-                                  (if (null? x-29289)
-                                    x-29289
+                                      expression-29531
+                                      wrap-29532
+                                      module-29533))
+                                  (if (null? x-29499)
+                                    x-29499
                                     (vector
                                       'syntax-object
-                                      x-29289
-                                      w-29034
-                                      mod-29037))))))
-                          x-29147)
+                                      x-29499
+                                      w-29244
+                                      mod-29247))))))
+                          x-29357)
                         (begin
-                          (if (if (pair? x-29147) s-29035 #f)
-                            (set-source-properties! x-29147 s-29035))
-                          x-29147))))))))
+                          (if (if (pair? x-29357) s-29245 #f)
+                            (set-source-properties! x-29357 s-29245))
+                          x-29357))))))))
            (with-fluids
-             ((transformer-environment-4572
-                (lambda (k-29039)
-                  (k-29039
-                    e-29032
-                    r-29033
-                    w-29034
-                    s-29035
-                    rib-29036
-                    mod-29037))))
-             (rebuild-macro-output-29038
-               (p-29031
-                 (let ((w-29046
-                         (cons (cons #f (car w-29034))
-                               (cons 'shift (cdr w-29034)))))
-                   (let ((x-29051
+             ((transformer-environment-4368
+                (lambda (k-29249)
+                  (k-29249
+                    e-29242
+                    r-29243
+                    w-29244
+                    s-29245
+                    rib-29246
+                    mod-29247))))
+             (rebuild-macro-output-29248
+               (p-29241
+                 (let ((w-29256
+                         (cons (cons #f (car w-29244))
+                               (cons 'shift (cdr w-29244)))))
+                   (let ((x-29261
                            (begin
-                             (if (if (pair? e-29032) s-29035 #f)
-                               (set-source-properties! e-29032 s-29035))
-                             e-29032)))
-                     (if (if (null? (car w-29046))
-                           (null? (cdr w-29046))
+                             (if (if (pair? e-29242) s-29245 #f)
+                               (set-source-properties! e-29242 s-29245))
+                             e-29242)))
+                     (if (if (null? (car w-29256))
+                           (null? (cdr w-29256))
                            #f)
-                       x-29051
-                       (if (if (vector? x-29051)
-                             (if (= (vector-length x-29051) 4)
-                               (eq? (vector-ref x-29051 0) 'syntax-object)
+                       x-29261
+                       (if (if (vector? x-29261)
+                             (if (= (vector-length x-29261) 4)
+                               (eq? (vector-ref x-29261 0) 'syntax-object)
                                #f)
                              #f)
-                         (let ((expression-29090 (vector-ref x-29051 1))
-                               (wrap-29091
-                                 (let ((w2-29099 (vector-ref x-29051 2)))
-                                   (let ((m1-29100 (car w-29046))
-                                         (s1-29101 (cdr w-29046)))
-                                     (if (null? m1-29100)
-                                       (if (null? s1-29101)
-                                         w2-29099
-                                         (cons (car w2-29099)
-                                               (let ((m2-29116 (cdr w2-29099)))
-                                                 (if (null? m2-29116)
-                                                   s1-29101
+                         (let ((expression-29300 (vector-ref x-29261 1))
+                               (wrap-29301
+                                 (let ((w2-29309 (vector-ref x-29261 2)))
+                                   (let ((m1-29310 (car w-29256))
+                                         (s1-29311 (cdr w-29256)))
+                                     (if (null? m1-29310)
+                                       (if (null? s1-29311)
+                                         w2-29309
+                                         (cons (car w2-29309)
+                                               (let ((m2-29326 (cdr w2-29309)))
+                                                 (if (null? m2-29326)
+                                                   s1-29311
                                                    (append
-                                                     s1-29101
-                                                     m2-29116)))))
-                                       (cons (let ((m2-29124 (car w2-29099)))
-                                               (if (null? m2-29124)
-                                                 m1-29100
-                                                 (append m1-29100 m2-29124)))
-                                             (let ((m2-29132 (cdr w2-29099)))
-                                               (if (null? m2-29132)
-                                                 s1-29101
+                                                     s1-29311
+                                                     m2-29326)))))
+                                       (cons (let ((m2-29334 (car w2-29309)))
+                                               (if (null? m2-29334)
+                                                 m1-29310
+                                                 (append m1-29310 m2-29334)))
+                                             (let ((m2-29342 (cdr w2-29309)))
+                                               (if (null? m2-29342)
+                                                 s1-29311
                                                  (append
-                                                   s1-29101
-                                                   m2-29132))))))))
-                               (module-29092 (vector-ref x-29051 3)))
+                                                   s1-29311
+                                                   m2-29342))))))))
+                               (module-29302 (vector-ref x-29261 3)))
                            (vector
                              'syntax-object
-                             expression-29090
-                             wrap-29091
-                             module-29092))
-                         (if (null? x-29051)
-                           x-29051
+                             expression-29300
+                             wrap-29301
+                             module-29302))
+                         (if (null? x-29261)
+                           x-29261
                            (vector
                              'syntax-object
-                             x-29051
-                             w-29046
-                             mod-29037)))))))
+                             x-29261
+                             w-29256
+                             mod-29247)))))))
                (gensym
-                 (string-append "m-" (session-id-4511) "-")))))))
-     (expand-body-4590
-       (lambda (body-29393
-                outer-form-29394
-                r-29395
-                w-29396
-                mod-29397)
-         (let ((r-29398
-                 (cons '("placeholder" placeholder) r-29395)))
-           (let ((ribcage-29399 (vector 'ribcage '() '() '())))
-             (let ((w-29400
-                     (cons (car w-29396)
-                           (cons ribcage-29399 (cdr w-29396)))))
+                 (string-append "m-" (session-id-4307) "-")))))))
+     (expand-body-4386
+       (lambda (body-29603
+                outer-form-29604
+                r-29605
+                w-29606
+                mod-29607)
+         (let ((r-29608
+                 (cons '("placeholder" placeholder) r-29605)))
+           (let ((ribcage-29609 (vector 'ribcage '() '() '())))
+             (let ((w-29610
+                     (cons (car w-29606)
+                           (cons ribcage-29609 (cdr w-29606)))))
                (letrec*
-                 ((parse-29401
-                    (lambda (body-29509
-                             ids-29510
-                             labels-29511
-                             var-ids-29512
-                             vars-29513
-                             vals-29514
-                             bindings-29515)
-                      (if (null? body-29509)
+                 ((parse-29611
+                    (lambda (body-29719
+                             ids-29720
+                             labels-29721
+                             var-ids-29722
+                             vars-29723
+                             vals-29724
+                             bindings-29725)
+                      (if (null? body-29719)
                         (syntax-violation
                           #f
                           "no expressions in body"
-                          outer-form-29394)
-                        (let ((e-29516 (cdr (car body-29509)))
-                              (er-29517 (car (car body-29509))))
+                          outer-form-29604)
+                        (let ((e-29726 (cdr (car body-29719)))
+                              (er-29727 (car (car body-29719))))
                           (call-with-values
                             (lambda ()
-                              (syntax-type-4585
-                                e-29516
-                                er-29517
+                              (syntax-type-4381
+                                e-29726
+                                er-29727
                                 '(())
-                                (source-annotation-4544 er-29517)
-                                ribcage-29399
-                                mod-29397
+                                (source-annotation-4340 er-29727)
+                                ribcage-29609
+                                mod-29607
                                 #f))
-                            (lambda (type-29705
-                                     value-29706
-                                     form-29707
-                                     e-29708
-                                     w-29709
-                                     s-29710
-                                     mod-29711)
-                              (if (eqv? type-29705 'define-form)
-                                (let ((id-29715
-                                        (if (if (null? (car w-29709))
-                                              (null? (cdr w-29709))
+                            (lambda (type-29915
+                                     value-29916
+                                     form-29917
+                                     e-29918
+                                     w-29919
+                                     s-29920
+                                     mod-29921)
+                              (if (eqv? type-29915 'define-form)
+                                (let ((id-29929
+                                        (if (if (null? (car w-29919))
+                                              (null? (cdr w-29919))
                                               #f)
-                                          value-29706
-                                          (if (if (vector? value-29706)
+                                          value-29916
+                                          (if (if (vector? value-29916)
                                                 (if (= (vector-length
-                                                         value-29706)
+                                                         value-29916)
                                                        4)
                                                   (eq? (vector-ref
-                                                         value-29706
+                                                         value-29916
                                                          0)
                                                        'syntax-object)
                                                   #f)
                                                 #f)
-                                            (let ((expression-29760
-                                                    (vector-ref value-29706 1))
-                                                  (wrap-29761
-                                                    (let ((w2-29771
+                                            (let ((expression-29974
+                                                    (vector-ref value-29916 1))
+                                                  (wrap-29975
+                                                    (let ((w2-29985
                                                             (vector-ref
-                                                              value-29706
+                                                              value-29916
                                                               2)))
-                                                      (let ((m1-29772
-                                                              (car w-29709))
-                                                            (s1-29773
-                                                              (cdr w-29709)))
-                                                        (if (null? m1-29772)
-                                                          (if (null? s1-29773)
-                                                            w2-29771
-                                                            (cons (car 
w2-29771)
-                                                                  (let 
((m2-29790
-                                                                          (cdr 
w2-29771)))
-                                                                    (if (null? 
m2-29790)
-                                                                      s1-29773
+                                                      (let ((m1-29986
+                                                              (car w-29919))
+                                                            (s1-29987
+                                                              (cdr w-29919)))
+                                                        (if (null? m1-29986)
+                                                          (if (null? s1-29987)
+                                                            w2-29985
+                                                            (cons (car 
w2-29985)
+                                                                  (let 
((m2-30004
+                                                                          (cdr 
w2-29985)))
+                                                                    (if (null? 
m2-30004)
+                                                                      s1-29987
                                                                       (append
-                                                                        
s1-29773
-                                                                        
m2-29790)))))
-                                                          (cons (let ((m2-29798
-                                                                        (car 
w2-29771)))
-                                                                  (if (null? 
m2-29798)
-                                                                    m1-29772
+                                                                        
s1-29987
+                                                                        
m2-30004)))))
+                                                          (cons (let ((m2-30012
+                                                                        (car 
w2-29985)))
+                                                                  (if (null? 
m2-30012)
+                                                                    m1-29986
                                                                     (append
-                                                                      m1-29772
-                                                                      
m2-29798)))
-                                                                (let ((m2-29806
-                                                                        (cdr 
w2-29771)))
-                                                                  (if (null? 
m2-29806)
-                                                                    s1-29773
+                                                                      m1-29986
+                                                                      
m2-30012)))
+                                                                (let ((m2-30020
+                                                                        (cdr 
w2-29985)))
+                                                                  (if (null? 
m2-30020)
+                                                                    s1-29987
                                                                     (append
-                                                                      s1-29773
-                                                                      
m2-29806))))))))
-                                                  (module-29762
+                                                                      s1-29987
+                                                                      
m2-30020))))))))
+                                                  (module-29976
                                                     (vector-ref
-                                                      value-29706
+                                                      value-29916
                                                       3)))
                                               (vector
                                                 'syntax-object
-                                                expression-29760
-                                                wrap-29761
-                                                module-29762))
-                                            (if (null? value-29706)
-                                              value-29706
+                                                expression-29974
+                                                wrap-29975
+                                                module-29976))
+                                            (if (null? value-29916)
+                                              value-29916
                                               (vector
                                                 'syntax-object
-                                                value-29706
-                                                w-29709
-                                                mod-29711)))))
-                                      (label-29716
+                                                value-29916
+                                                w-29919
+                                                mod-29921)))))
+                                      (label-29930
                                         (string-append
                                           "l-"
-                                          (session-id-4511)
+                                          (session-id-4307)
                                           (symbol->string (gensym "-")))))
-                                  (let ((var-29717
-                                          (let ((id-29867
-                                                  (if (if (vector? id-29715)
+                                  (let ((var-29931
+                                          (let ((id-30081
+                                                  (if (if (vector? id-29929)
                                                         (if (= (vector-length
-                                                                 id-29715)
+                                                                 id-29929)
                                                                4)
                                                           (eq? (vector-ref
-                                                                 id-29715
+                                                                 id-29929
                                                                  0)
                                                                'syntax-object)
                                                           #f)
                                                         #f)
-                                                    (vector-ref id-29715 1)
-                                                    id-29715)))
+                                                    (vector-ref id-29929 1)
+                                                    id-29929)))
                                             (gensym
                                               (string-append
-                                                (symbol->string id-29867)
+                                                (symbol->string id-30081)
                                                 "-")))))
                                     (begin
                                       (begin
-                                        (let ((update-29726
-                                                (cons (vector-ref id-29715 1)
+                                        (let ((update-29940
+                                                (cons (vector-ref id-29929 1)
                                                       (vector-ref
-                                                        ribcage-29399
+                                                        ribcage-29609
                                                         1))))
                                           (vector-set!
-                                            ribcage-29399
+                                            ribcage-29609
                                             1
-                                            update-29726))
-                                        (let ((update-29838
+                                            update-29940))
+                                        (let ((update-30052
                                                 (cons (car (vector-ref
-                                                             id-29715
+                                                             id-29929
                                                              2))
                                                       (vector-ref
-                                                        ribcage-29399
+                                                        ribcage-29609
                                                         2))))
                                           (vector-set!
-                                            ribcage-29399
+                                            ribcage-29609
                                             2
-                                            update-29838))
-                                        (let ((update-29853
-                                                (cons label-29716
+                                            update-30052))
+                                        (let ((update-30067
+                                                (cons label-29930
                                                       (vector-ref
-                                                        ribcage-29399
+                                                        ribcage-29609
                                                         3))))
                                           (vector-set!
-                                            ribcage-29399
+                                            ribcage-29609
                                             3
-                                            update-29853)))
-                                      (parse-29401
-                                        (cdr body-29509)
-                                        (cons id-29715 ids-29510)
-                                        (cons label-29716 labels-29511)
-                                        (cons id-29715 var-ids-29512)
-                                        (cons var-29717 vars-29513)
-                                        (cons (cons er-29517
-                                                    (if (if (null? (car 
w-29709))
-                                                          (null? (cdr w-29709))
+                                            update-30067)))
+                                      (parse-29611
+                                        (cdr body-29719)
+                                        (cons id-29929 ids-29720)
+                                        (cons label-29930 labels-29721)
+                                        (cons id-29929 var-ids-29722)
+                                        (cons var-29931 vars-29723)
+                                        (cons (cons er-29727
+                                                    (if (if (null? (car 
w-29919))
+                                                          (null? (cdr w-29919))
                                                           #f)
-                                                      e-29708
-                                                      (if (if (vector? e-29708)
+                                                      e-29918
+                                                      (if (if (vector? e-29918)
                                                             (if (= 
(vector-length
-                                                                     e-29708)
+                                                                     e-29918)
                                                                    4)
                                                               (eq? (vector-ref
-                                                                     e-29708
+                                                                     e-29918
                                                                      0)
                                                                    
'syntax-object)
                                                               #f)
                                                             #f)
-                                                        (let ((expression-29919
+                                                        (let ((expression-30133
                                                                 (vector-ref
-                                                                  e-29708
+                                                                  e-29918
                                                                   1))
-                                                              (wrap-29920
-                                                                (let ((w2-29930
+                                                              (wrap-30134
+                                                                (let ((w2-30144
                                                                         
(vector-ref
-                                                                          
e-29708
+                                                                          
e-29918
                                                                           2)))
-                                                                  (let 
((m1-29931
-                                                                          (car 
w-29709))
-                                                                        
(s1-29932
-                                                                          (cdr 
w-29709)))
-                                                                    (if (null? 
m1-29931)
-                                                                      (if 
(null? s1-29932)
-                                                                        
w2-29930
-                                                                        (cons 
(car w2-29930)
-                                                                              
(let ((m2-29949
-                                                                               
       (cdr w2-29930)))
-                                                                               
 (if (null? m2-29949)
-                                                                               
   s1-29932
+                                                                  (let 
((m1-30145
+                                                                          (car 
w-29919))
+                                                                        
(s1-30146
+                                                                          (cdr 
w-29919)))
+                                                                    (if (null? 
m1-30145)
+                                                                      (if 
(null? s1-30146)
+                                                                        
w2-30144
+                                                                        (cons 
(car w2-30144)
+                                                                              
(let ((m2-30163
+                                                                               
       (cdr w2-30144)))
+                                                                               
 (if (null? m2-30163)
+                                                                               
   s1-30146
                                                                                
   (append
-                                                                               
     s1-29932
-                                                                               
     m2-29949)))))
-                                                                      (cons 
(let ((m2-29957
-                                                                               
     (car w2-29930)))
-                                                                              
(if (null? m2-29957)
-                                                                               
 m1-29931
+                                                                               
     s1-30146
+                                                                               
     m2-30163)))))
+                                                                      (cons 
(let ((m2-30171
+                                                                               
     (car w2-30144)))
+                                                                              
(if (null? m2-30171)
+                                                                               
 m1-30145
                                                                                
 (append
-                                                                               
   m1-29931
-                                                                               
   m2-29957)))
-                                                                            
(let ((m2-29965
-                                                                               
     (cdr w2-29930)))
-                                                                              
(if (null? m2-29965)
-                                                                               
 s1-29932
+                                                                               
   m1-30145
+                                                                               
   m2-30171)))
+                                                                            
(let ((m2-30179
+                                                                               
     (cdr w2-30144)))
+                                                                              
(if (null? m2-30179)
+                                                                               
 s1-30146
                                                                                
 (append
-                                                                               
   s1-29932
-                                                                               
   m2-29965))))))))
-                                                              (module-29921
+                                                                               
   s1-30146
+                                                                               
   m2-30179))))))))
+                                                              (module-30135
                                                                 (vector-ref
-                                                                  e-29708
+                                                                  e-29918
                                                                   3)))
                                                           (vector
                                                             'syntax-object
-                                                            expression-29919
-                                                            wrap-29920
-                                                            module-29921))
-                                                        (if (null? e-29708)
-                                                          e-29708
+                                                            expression-30133
+                                                            wrap-30134
+                                                            module-30135))
+                                                        (if (null? e-29918)
+                                                          e-29918
                                                           (vector
                                                             'syntax-object
-                                                            e-29708
-                                                            w-29709
-                                                            mod-29711)))))
-                                              vals-29514)
-                                        (cons (cons 'lexical var-29717)
-                                              bindings-29515)))))
-                                (if (if (eqv? type-29705 'define-syntax-form)
+                                                            e-29918
+                                                            w-29919
+                                                            mod-29921)))))
+                                              vals-29724)
+                                        (cons (cons 'lexical var-29931)
+                                              bindings-29725)))))
+                                (if (if (eqv? type-29915 'define-syntax-form)
                                       #t
-                                      (eqv? type-29705
+                                      (eqv? type-29915
                                             'define-syntax-parameter-form))
-                                  (let ((id-29996
-                                          (if (if (null? (car w-29709))
-                                                (null? (cdr w-29709))
+                                  (let ((id-30213
+                                          (if (if (null? (car w-29919))
+                                                (null? (cdr w-29919))
                                                 #f)
-                                            value-29706
-                                            (if (if (vector? value-29706)
+                                            value-29916
+                                            (if (if (vector? value-29916)
                                                   (if (= (vector-length
-                                                           value-29706)
+                                                           value-29916)
                                                          4)
                                                     (eq? (vector-ref
-                                                           value-29706
+                                                           value-29916
                                                            0)
                                                          'syntax-object)
                                                     #f)
                                                   #f)
-                                              (let ((expression-30040
+                                              (let ((expression-30257
                                                       (vector-ref
-                                                        value-29706
+                                                        value-29916
                                                         1))
-                                                    (wrap-30041
-                                                      (let ((w2-30051
+                                                    (wrap-30258
+                                                      (let ((w2-30268
                                                               (vector-ref
-                                                                value-29706
+                                                                value-29916
                                                                 2)))
-                                                        (let ((m1-30052
-                                                                (car w-29709))
-                                                              (s1-30053
-                                                                (cdr w-29709)))
-                                                          (if (null? m1-30052)
-                                                            (if (null? 
s1-30053)
-                                                              w2-30051
-                                                              (cons (car 
w2-30051)
-                                                                    (let 
((m2-30070
-                                                                            
(cdr w2-30051)))
-                                                                      (if 
(null? m2-30070)
-                                                                        
s1-30053
+                                                        (let ((m1-30269
+                                                                (car w-29919))
+                                                              (s1-30270
+                                                                (cdr w-29919)))
+                                                          (if (null? m1-30269)
+                                                            (if (null? 
s1-30270)
+                                                              w2-30268
+                                                              (cons (car 
w2-30268)
+                                                                    (let 
((m2-30287
+                                                                            
(cdr w2-30268)))
+                                                                      (if 
(null? m2-30287)
+                                                                        
s1-30270
                                                                         (append
-                                                                          
s1-30053
-                                                                          
m2-30070)))))
-                                                            (cons (let 
((m2-30078
-                                                                          (car 
w2-30051)))
-                                                                    (if (null? 
m2-30078)
-                                                                      m1-30052
+                                                                          
s1-30270
+                                                                          
m2-30287)))))
+                                                            (cons (let 
((m2-30295
+                                                                          (car 
w2-30268)))
+                                                                    (if (null? 
m2-30295)
+                                                                      m1-30269
                                                                       (append
-                                                                        
m1-30052
-                                                                        
m2-30078)))
-                                                                  (let 
((m2-30086
-                                                                          (cdr 
w2-30051)))
-                                                                    (if (null? 
m2-30086)
-                                                                      s1-30053
+                                                                        
m1-30269
+                                                                        
m2-30295)))
+                                                                  (let 
((m2-30303
+                                                                          (cdr 
w2-30268)))
+                                                                    (if (null? 
m2-30303)
+                                                                      s1-30270
                                                                       (append
-                                                                        
s1-30053
-                                                                        
m2-30086))))))))
-                                                    (module-30042
+                                                                        
s1-30270
+                                                                        
m2-30303))))))))
+                                                    (module-30259
                                                       (vector-ref
-                                                        value-29706
+                                                        value-29916
                                                         3)))
                                                 (vector
                                                   'syntax-object
-                                                  expression-30040
-                                                  wrap-30041
-                                                  module-30042))
-                                              (if (null? value-29706)
-                                                value-29706
+                                                  expression-30257
+                                                  wrap-30258
+                                                  module-30259))
+                                              (if (null? value-29916)
+                                                value-29916
                                                 (vector
                                                   'syntax-object
-                                                  value-29706
-                                                  w-29709
-                                                  mod-29711)))))
-                                        (label-29997
+                                                  value-29916
+                                                  w-29919
+                                                  mod-29921)))))
+                                        (label-30214
                                           (string-append
                                             "l-"
-                                            (session-id-4511)
+                                            (session-id-4307)
                                             (symbol->string (gensym "-")))))
                                     (begin
                                       (begin
-                                        (let ((update-30006
-                                                (cons (vector-ref id-29996 1)
+                                        (let ((update-30223
+                                                (cons (vector-ref id-30213 1)
                                                       (vector-ref
-                                                        ribcage-29399
+                                                        ribcage-29609
                                                         1))))
                                           (vector-set!
-                                            ribcage-29399
+                                            ribcage-29609
                                             1
-                                            update-30006))
-                                        (let ((update-30118
+                                            update-30223))
+                                        (let ((update-30335
                                                 (cons (car (vector-ref
-                                                             id-29996
+                                                             id-30213
                                                              2))
                                                       (vector-ref
-                                                        ribcage-29399
+                                                        ribcage-29609
                                                         2))))
                                           (vector-set!
-                                            ribcage-29399
+                                            ribcage-29609
                                             2
-                                            update-30118))
-                                        (let ((update-30133
-                                                (cons label-29997
+                                            update-30335))
+                                        (let ((update-30350
+                                                (cons label-30214
                                                       (vector-ref
-                                                        ribcage-29399
+                                                        ribcage-29609
                                                         3))))
                                           (vector-set!
-                                            ribcage-29399
+                                            ribcage-29609
                                             3
-                                            update-30133)))
-                                      (parse-29401
-                                        (cdr body-29509)
-                                        (cons id-29996 ids-29510)
-                                        (cons label-29997 labels-29511)
-                                        var-ids-29512
-                                        vars-29513
-                                        vals-29514
-                                        (cons (cons (if (eq? type-29705
+                                            update-30350)))
+                                      (parse-29611
+                                        (cdr body-29719)
+                                        (cons id-30213 ids-29720)
+                                        (cons label-30214 labels-29721)
+                                        var-ids-29722
+                                        vars-29723
+                                        vals-29724
+                                        (cons (cons (if (eq? type-29915
                                                              
'define-syntax-parameter-form)
                                                       'syntax-parameter
                                                       'macro)
-                                                    (cons er-29517
-                                                          (if (if (null? (car 
w-29709))
-                                                                (null? (cdr 
w-29709))
+                                                    (cons er-29727
+                                                          (if (if (null? (car 
w-29919))
+                                                                (null? (cdr 
w-29919))
                                                                 #f)
-                                                            e-29708
+                                                            e-29918
                                                             (if (if (vector?
-                                                                      e-29708)
+                                                                      e-29918)
                                                                   (if (= 
(vector-length
-                                                                           
e-29708)
+                                                                           
e-29918)
                                                                          4)
                                                                     (eq? 
(vector-ref
-                                                                           
e-29708
+                                                                           
e-29918
                                                                            0)
                                                                          
'syntax-object)
                                                                     #f)
                                                                   #f)
-                                                              (let 
((expression-30172
+                                                              (let 
((expression-30389
                                                                       
(vector-ref
-                                                                        e-29708
+                                                                        e-29918
                                                                         1))
-                                                                    (wrap-30173
-                                                                      (let 
((w2-30183
+                                                                    (wrap-30390
+                                                                      (let 
((w2-30400
                                                                               
(vector-ref
-                                                                               
 e-29708
+                                                                               
 e-29918
                                                                                
 2)))
-                                                                        (let 
((m1-30184
-                                                                               
 (car w-29709))
-                                                                              
(s1-30185
-                                                                               
 (cdr w-29709)))
-                                                                          (if 
(null? m1-30184)
-                                                                            
(if (null? s1-30185)
-                                                                              
w2-30183
-                                                                              
(cons (car w2-30183)
-                                                                               
     (let ((m2-30202
-                                                                               
             (cdr w2-30183)))
-                                                                               
       (if (null? m2-30202)
-                                                                               
         s1-30185
+                                                                        (let 
((m1-30401
+                                                                               
 (car w-29919))
+                                                                              
(s1-30402
+                                                                               
 (cdr w-29919)))
+                                                                          (if 
(null? m1-30401)
+                                                                            
(if (null? s1-30402)
+                                                                              
w2-30400
+                                                                              
(cons (car w2-30400)
+                                                                               
     (let ((m2-30419
+                                                                               
             (cdr w2-30400)))
+                                                                               
       (if (null? m2-30419)
+                                                                               
         s1-30402
                                                                                
         (append
-                                                                               
           s1-30185
-                                                                               
           m2-30202)))))
-                                                                            
(cons (let ((m2-30210
-                                                                               
           (car w2-30183)))
-                                                                               
     (if (null? m2-30210)
-                                                                               
       m1-30184
+                                                                               
           s1-30402
+                                                                               
           m2-30419)))))
+                                                                            
(cons (let ((m2-30427
+                                                                               
           (car w2-30400)))
+                                                                               
     (if (null? m2-30427)
+                                                                               
       m1-30401
                                                                                
       (append
-                                                                               
         m1-30184
-                                                                               
         m2-30210)))
-                                                                               
   (let ((m2-30218
-                                                                               
           (cdr w2-30183)))
-                                                                               
     (if (null? m2-30218)
-                                                                               
       s1-30185
+                                                                               
         m1-30401
+                                                                               
         m2-30427)))
+                                                                               
   (let ((m2-30435
+                                                                               
           (cdr w2-30400)))
+                                                                               
     (if (null? m2-30435)
+                                                                               
       s1-30402
                                                                                
       (append
-                                                                               
         s1-30185
-                                                                               
         m2-30218))))))))
-                                                                    
(module-30174
+                                                                               
         s1-30402
+                                                                               
         m2-30435))))))))
+                                                                    
(module-30391
                                                                       
(vector-ref
-                                                                        e-29708
+                                                                        e-29918
                                                                         3)))
                                                                 (vector
                                                                   
'syntax-object
-                                                                  
expression-30172
-                                                                  wrap-30173
-                                                                  
module-30174))
-                                                              (if (null? 
e-29708)
-                                                                e-29708
+                                                                  
expression-30389
+                                                                  wrap-30390
+                                                                  
module-30391))
+                                                              (if (null? 
e-29918)
+                                                                e-29918
                                                                 (vector
                                                                   
'syntax-object
-                                                                  e-29708
-                                                                  w-29709
-                                                                  
mod-29711))))))
-                                              bindings-29515))))
-                                  (if (eqv? type-29705 'begin-form)
-                                    (let ((tmp-30245
+                                                                  e-29918
+                                                                  w-29919
+                                                                  
mod-29921))))))
+                                              bindings-29725))))
+                                  (if (eqv? type-29915 'begin-form)
+                                    (let ((tmp-30465
                                             ($sc-dispatch
-                                              e-29708
+                                              e-29918
                                               '(_ . each-any))))
-                                      (if tmp-30245
+                                      (if tmp-30465
                                         (@apply
-                                          (lambda (e1-30249)
-                                            (parse-29401
+                                          (lambda (e1-30469)
+                                            (parse-29611
                                               (letrec*
-                                                ((f-30250
-                                                   (lambda (forms-30451)
-                                                     (if (null? forms-30451)
-                                                       (cdr body-29509)
-                                                       (cons (cons er-29517
-                                                                   (let 
((x-30455
-                                                                           
(car forms-30451)))
-                                                                     (if (if 
(null? (car w-29709))
-                                                                           
(null? (cdr w-29709))
+                                                ((f-30470
+                                                   (lambda (forms-30671)
+                                                     (if (null? forms-30671)
+                                                       (cdr body-29719)
+                                                       (cons (cons er-29727
+                                                                   (let 
((x-30675
+                                                                           
(car forms-30671)))
+                                                                     (if (if 
(null? (car w-29919))
+                                                                           
(null? (cdr w-29919))
                                                                            #f)
-                                                                       x-30455
+                                                                       x-30675
                                                                        (if (if 
(vector?
-                                                                               
  x-30455)
+                                                                               
  x-30675)
                                                                              
(if (= (vector-length
-                                                                               
       x-30455)
+                                                                               
       x-30675)
                                                                                
     4)
                                                                                
(eq? (vector-ref
-                                                                               
       x-30455
+                                                                               
       x-30675
                                                                                
       0)
                                                                                
     'syntax-object)
                                                                                
#f)
                                                                              
#f)
-                                                                         (let 
((expression-30473
+                                                                         (let 
((expression-30693
                                                                                
  (vector-ref
-                                                                               
    x-30455
+                                                                               
    x-30675
                                                                                
    1))
-                                                                               
(wrap-30474
-                                                                               
  (let ((w2-30482
+                                                                               
(wrap-30694
+                                                                               
  (let ((w2-30702
                                                                                
          (vector-ref
-                                                                               
            x-30455
+                                                                               
            x-30675
                                                                                
            2)))
-                                                                               
    (let ((m1-30483
-                                                                               
            (car w-29709))
-                                                                               
          (s1-30484
-                                                                               
            (cdr w-29709)))
-                                                                               
      (if (null? m1-30483)
-                                                                               
        (if (null? s1-30484)
-                                                                               
          w2-30482
-                                                                               
          (cons (car w2-30482)
-                                                                               
                (let ((m2-30499
-                                                                               
                        (cdr w2-30482)))
-                                                                               
                  (if (null? m2-30499)
-                                                                               
                    s1-30484
+                                                                               
    (let ((m1-30703
+                                                                               
            (car w-29919))
+                                                                               
          (s1-30704
+                                                                               
            (cdr w-29919)))
+                                                                               
      (if (null? m1-30703)
+                                                                               
        (if (null? s1-30704)
+                                                                               
          w2-30702
+                                                                               
          (cons (car w2-30702)
+                                                                               
                (let ((m2-30719
+                                                                               
                        (cdr w2-30702)))
+                                                                               
                  (if (null? m2-30719)
+                                                                               
                    s1-30704
                                                                                
                    (append
-                                                                               
                      s1-30484
-                                                                               
                      m2-30499)))))
-                                                                               
        (cons (let ((m2-30507
-                                                                               
                      (car w2-30482)))
-                                                                               
                (if (null? m2-30507)
-                                                                               
                  m1-30483
+                                                                               
                      s1-30704
+                                                                               
                      m2-30719)))))
+                                                                               
        (cons (let ((m2-30727
+                                                                               
                      (car w2-30702)))
+                                                                               
                (if (null? m2-30727)
+                                                                               
                  m1-30703
                                                                                
                  (append
-                                                                               
                    m1-30483
-                                                                               
                    m2-30507)))
-                                                                               
              (let ((m2-30515
-                                                                               
                      (cdr w2-30482)))
-                                                                               
                (if (null? m2-30515)
-                                                                               
                  s1-30484
+                                                                               
                    m1-30703
+                                                                               
                    m2-30727)))
+                                                                               
              (let ((m2-30735
+                                                                               
                      (cdr w2-30702)))
+                                                                               
                (if (null? m2-30735)
+                                                                               
                  s1-30704
                                                                                
                  (append
-                                                                               
                    s1-30484
-                                                                               
                    m2-30515))))))))
-                                                                               
(module-30475
+                                                                               
                    s1-30704
+                                                                               
                    m2-30735))))))))
+                                                                               
(module-30695
                                                                                
  (vector-ref
-                                                                               
    x-30455
+                                                                               
    x-30675
                                                                                
    3)))
                                                                            
(vector
                                                                              
'syntax-object
-                                                                             
expression-30473
-                                                                             
wrap-30474
-                                                                             
module-30475))
-                                                                         (if 
(null? x-30455)
-                                                                           
x-30455
+                                                                             
expression-30693
+                                                                             
wrap-30694
+                                                                             
module-30695))
+                                                                         (if 
(null? x-30675)
+                                                                           
x-30675
                                                                            
(vector
                                                                              
'syntax-object
-                                                                             
x-30455
-                                                                             
w-29709
-                                                                             
mod-29711))))))
-                                                             (f-30250
-                                                               (cdr 
forms-30451)))))))
-                                                (f-30250 e1-30249))
-                                              ids-29510
-                                              labels-29511
-                                              var-ids-29512
-                                              vars-29513
-                                              vals-29514
-                                              bindings-29515))
-                                          tmp-30245)
+                                                                             
x-30675
+                                                                             
w-29919
+                                                                             
mod-29921))))))
+                                                             (f-30470
+                                                               (cdr 
forms-30671)))))))
+                                                (f-30470 e1-30469))
+                                              ids-29720
+                                              labels-29721
+                                              var-ids-29722
+                                              vars-29723
+                                              vals-29724
+                                              bindings-29725))
+                                          tmp-30465)
                                         (syntax-violation
                                           #f
                                           "source expression failed to match 
any pattern"
-                                          e-29708)))
-                                    (if (eqv? type-29705 'local-syntax-form)
-                                      (expand-local-syntax-4591
-                                        value-29706
-                                        e-29708
-                                        er-29517
-                                        w-29709
-                                        s-29710
-                                        mod-29711
-                                        (lambda (forms-30541
-                                                 er-30542
-                                                 w-30543
-                                                 s-30544
-                                                 mod-30545)
-                                          (parse-29401
+                                          e-29918)))
+                                    (if (eqv? type-29915 'local-syntax-form)
+                                      (expand-local-syntax-4387
+                                        value-29916
+                                        e-29918
+                                        er-29727
+                                        w-29919
+                                        s-29920
+                                        mod-29921
+                                        (lambda (forms-30764
+                                                 er-30765
+                                                 w-30766
+                                                 s-30767
+                                                 mod-30768)
+                                          (parse-29611
                                             (letrec*
-                                              ((f-30546
-                                                 (lambda (forms-30747)
-                                                   (if (null? forms-30747)
-                                                     (cdr body-29509)
-                                                     (cons (cons er-30542
-                                                                 (let ((x-30751
-                                                                         (car 
forms-30747)))
-                                                                   (if (if 
(null? (car w-30543))
-                                                                         
(null? (cdr w-30543))
+                                              ((f-30769
+                                                 (lambda (forms-30970)
+                                                   (if (null? forms-30970)
+                                                     (cdr body-29719)
+                                                     (cons (cons er-30765
+                                                                 (let ((x-30974
+                                                                         (car 
forms-30970)))
+                                                                   (if (if 
(null? (car w-30766))
+                                                                         
(null? (cdr w-30766))
                                                                          #f)
-                                                                     x-30751
+                                                                     x-30974
                                                                      (if (if 
(vector?
-                                                                               
x-30751)
+                                                                               
x-30974)
                                                                            (if 
(= (vector-length
-                                                                               
     x-30751)
+                                                                               
     x-30974)
                                                                                
   4)
                                                                              
(eq? (vector-ref
-                                                                               
     x-30751
+                                                                               
     x-30974
                                                                                
     0)
                                                                                
   'syntax-object)
                                                                              
#f)
                                                                            #f)
-                                                                       (let 
((expression-30769
+                                                                       (let 
((expression-30992
                                                                                
(vector-ref
-                                                                               
  x-30751
+                                                                               
  x-30974
                                                                                
  1))
-                                                                             
(wrap-30770
-                                                                               
(let ((w2-30778
+                                                                             
(wrap-30993
+                                                                               
(let ((w2-31001
                                                                                
        (vector-ref
-                                                                               
          x-30751
+                                                                               
          x-30974
                                                                                
          2)))
-                                                                               
  (let ((m1-30779
-                                                                               
          (car w-30543))
-                                                                               
        (s1-30780
-                                                                               
          (cdr w-30543)))
-                                                                               
    (if (null? m1-30779)
-                                                                               
      (if (null? s1-30780)
-                                                                               
        w2-30778
-                                                                               
        (cons (car w2-30778)
-                                                                               
              (let ((m2-30795
-                                                                               
                      (cdr w2-30778)))
-                                                                               
                (if (null? m2-30795)
-                                                                               
                  s1-30780
+                                                                               
  (let ((m1-31002
+                                                                               
          (car w-30766))
+                                                                               
        (s1-31003
+                                                                               
          (cdr w-30766)))
+                                                                               
    (if (null? m1-31002)
+                                                                               
      (if (null? s1-31003)
+                                                                               
        w2-31001
+                                                                               
        (cons (car w2-31001)
+                                                                               
              (let ((m2-31018
+                                                                               
                      (cdr w2-31001)))
+                                                                               
                (if (null? m2-31018)
+                                                                               
                  s1-31003
                                                                                
                  (append
-                                                                               
                    s1-30780
-                                                                               
                    m2-30795)))))
-                                                                               
      (cons (let ((m2-30803
-                                                                               
                    (car w2-30778)))
-                                                                               
              (if (null? m2-30803)
-                                                                               
                m1-30779
+                                                                               
                    s1-31003
+                                                                               
                    m2-31018)))))
+                                                                               
      (cons (let ((m2-31026
+                                                                               
                    (car w2-31001)))
+                                                                               
              (if (null? m2-31026)
+                                                                               
                m1-31002
                                                                                
                (append
-                                                                               
                  m1-30779
-                                                                               
                  m2-30803)))
-                                                                               
            (let ((m2-30811
-                                                                               
                    (cdr w2-30778)))
-                                                                               
              (if (null? m2-30811)
-                                                                               
                s1-30780
+                                                                               
                  m1-31002
+                                                                               
                  m2-31026)))
+                                                                               
            (let ((m2-31034
+                                                                               
                    (cdr w2-31001)))
+                                                                               
              (if (null? m2-31034)
+                                                                               
                s1-31003
                                                                                
                (append
-                                                                               
                  s1-30780
-                                                                               
                  m2-30811))))))))
-                                                                             
(module-30771
+                                                                               
                  s1-31003
+                                                                               
                  m2-31034))))))))
+                                                                             
(module-30994
                                                                                
(vector-ref
-                                                                               
  x-30751
+                                                                               
  x-30974
                                                                                
  3)))
                                                                          
(vector
                                                                            
'syntax-object
-                                                                           
expression-30769
-                                                                           
wrap-30770
-                                                                           
module-30771))
-                                                                       (if 
(null? x-30751)
-                                                                         
x-30751
+                                                                           
expression-30992
+                                                                           
wrap-30993
+                                                                           
module-30994))
+                                                                       (if 
(null? x-30974)
+                                                                         
x-30974
                                                                          
(vector
                                                                            
'syntax-object
-                                                                           
x-30751
-                                                                           
w-30543
-                                                                           
mod-30545))))))
-                                                           (f-30546
-                                                             (cdr 
forms-30747)))))))
-                                              (f-30546 forms-30541))
-                                            ids-29510
-                                            labels-29511
-                                            var-ids-29512
-                                            vars-29513
-                                            vals-29514
-                                            bindings-29515)))
-                                      (if (null? ids-29510)
-                                        (build-sequence-4532
+                                                                           
x-30974
+                                                                           
w-30766
+                                                                           
mod-30768))))))
+                                                           (f-30769
+                                                             (cdr 
forms-30970)))))))
+                                              (f-30769 forms-30764))
+                                            ids-29720
+                                            labels-29721
+                                            var-ids-29722
+                                            vars-29723
+                                            vals-29724
+                                            bindings-29725)))
+                                      (if (null? ids-29720)
+                                        (build-sequence-4328
                                           #f
-                                          (map (lambda (x-30896)
-                                                 (expand-4586
-                                                   (cdr x-30896)
-                                                   (car x-30896)
+                                          (map (lambda (x-31119)
+                                                 (expand-4382
+                                                   (cdr x-31119)
+                                                   (car x-31119)
                                                    '(())
-                                                   mod-29711))
-                                               (cons (cons er-29517
-                                                           (let ((x-30971
+                                                   mod-29921))
+                                               (cons (cons er-29727
+                                                           (let ((x-31194
                                                                    (begin
-                                                                     (if (if 
(pair? e-29708)
-                                                                           
s-29710
+                                                                     (if (if 
(pair? e-29918)
+                                                                           
s-29920
                                                                            #f)
                                                                        
(set-source-properties!
-                                                                         
e-29708
-                                                                         
s-29710))
-                                                                     e-29708)))
-                                                             (if (if (null? 
(car w-29709))
-                                                                   (null? (cdr 
w-29709))
+                                                                         
e-29918
+                                                                         
s-29920))
+                                                                     e-29918)))
+                                                             (if (if (null? 
(car w-29919))
+                                                                   (null? (cdr 
w-29919))
                                                                    #f)
-                                                               x-30971
+                                                               x-31194
                                                                (if (if (vector?
-                                                                         
x-30971)
+                                                                         
x-31194)
                                                                      (if (= 
(vector-length
-                                                                              
x-30971)
+                                                                              
x-31194)
                                                                             4)
                                                                        (eq? 
(vector-ref
-                                                                              
x-30971
+                                                                              
x-31194
                                                                               
0)
                                                                             
'syntax-object)
                                                                        #f)
                                                                      #f)
-                                                                 (let 
((expression-31003
+                                                                 (let 
((expression-31226
                                                                          
(vector-ref
-                                                                           
x-30971
+                                                                           
x-31194
                                                                            1))
-                                                                       
(wrap-31004
-                                                                         (let 
((w2-31012
+                                                                       
(wrap-31227
+                                                                         (let 
((w2-31235
                                                                                
  (vector-ref
-                                                                               
    x-30971
+                                                                               
    x-31194
                                                                                
    2)))
-                                                                           
(let ((m1-31013
-                                                                               
    (car w-29709))
-                                                                               
  (s1-31014
-                                                                               
    (cdr w-29709)))
-                                                                             
(if (null? m1-31013)
-                                                                               
(if (null? s1-31014)
-                                                                               
  w2-31012
-                                                                               
  (cons (car w2-31012)
-                                                                               
        (let ((m2-31029
-                                                                               
                (cdr w2-31012)))
-                                                                               
          (if (null? m2-31029)
-                                                                               
            s1-31014
+                                                                           
(let ((m1-31236
+                                                                               
    (car w-29919))
+                                                                               
  (s1-31237
+                                                                               
    (cdr w-29919)))
+                                                                             
(if (null? m1-31236)
+                                                                               
(if (null? s1-31237)
+                                                                               
  w2-31235
+                                                                               
  (cons (car w2-31235)
+                                                                               
        (let ((m2-31252
+                                                                               
                (cdr w2-31235)))
+                                                                               
          (if (null? m2-31252)
+                                                                               
            s1-31237
                                                                                
            (append
-                                                                               
              s1-31014
-                                                                               
              m2-31029)))))
-                                                                               
(cons (let ((m2-31037
-                                                                               
              (car w2-31012)))
-                                                                               
        (if (null? m2-31037)
-                                                                               
          m1-31013
+                                                                               
              s1-31237
+                                                                               
              m2-31252)))))
+                                                                               
(cons (let ((m2-31260
+                                                                               
              (car w2-31235)))
+                                                                               
        (if (null? m2-31260)
+                                                                               
          m1-31236
                                                                                
          (append
-                                                                               
            m1-31013
-                                                                               
            m2-31037)))
-                                                                               
      (let ((m2-31045
-                                                                               
              (cdr w2-31012)))
-                                                                               
        (if (null? m2-31045)
-                                                                               
          s1-31014
+                                                                               
            m1-31236
+                                                                               
            m2-31260)))
+                                                                               
      (let ((m2-31268
+                                                                               
              (cdr w2-31235)))
+                                                                               
        (if (null? m2-31268)
+                                                                               
          s1-31237
                                                                                
          (append
-                                                                               
            s1-31014
-                                                                               
            m2-31045))))))))
-                                                                       
(module-31005
+                                                                               
            s1-31237
+                                                                               
            m2-31268))))))))
+                                                                       
(module-31228
                                                                          
(vector-ref
-                                                                           
x-30971
+                                                                           
x-31194
                                                                            3)))
                                                                    (vector
                                                                      
'syntax-object
-                                                                     
expression-31003
-                                                                     wrap-31004
-                                                                     
module-31005))
-                                                                 (if (null? 
x-30971)
-                                                                   x-30971
+                                                                     
expression-31226
+                                                                     wrap-31227
+                                                                     
module-31228))
+                                                                 (if (null? 
x-31194)
+                                                                   x-31194
                                                                    (vector
                                                                      
'syntax-object
-                                                                     x-30971
-                                                                     w-29709
-                                                                     
mod-29711))))))
-                                                     (cdr body-29509))))
+                                                                     x-31194
+                                                                     w-29919
+                                                                     
mod-29921))))))
+                                                     (cdr body-29719))))
                                         (begin
-                                          (if (not (valid-bound-ids?-4576
-                                                     ids-29510))
+                                          (if (not (valid-bound-ids?-4372
+                                                     ids-29720))
                                             (syntax-violation
                                               #f
                                               "invalid or duplicate identifier 
in definition"
-                                              outer-form-29394))
+                                              outer-form-29604))
                                           (letrec*
-                                            ((loop-31144
-                                               (lambda (bs-31147
-                                                        er-cache-31148
-                                                        r-cache-31149)
-                                                 (if (not (null? bs-31147))
-                                                   (let ((b-31150
-                                                           (car bs-31147)))
-                                                     (if (let ((t-31153
-                                                                 (car 
b-31150)))
-                                                           (if (eq? t-31153
+                                            ((loop-31367
+                                               (lambda (bs-31370
+                                                        er-cache-31371
+                                                        r-cache-31372)
+                                                 (if (not (null? bs-31370))
+                                                   (let ((b-31373
+                                                           (car bs-31370)))
+                                                     (if (let ((t-31376
+                                                                 (car 
b-31373)))
+                                                           (if (eq? t-31376
                                                                     'macro)
                                                              #t
-                                                             (eq? t-31153
+                                                             (eq? t-31376
                                                                   
'syntax-parameter)))
-                                                       (let ((er-31155
-                                                               (car (cdr 
b-31150))))
-                                                         (let ((r-cache-31156
-                                                                 (if (eq? 
er-31155
-                                                                          
er-cache-31148)
-                                                                   
r-cache-31149
-                                                                   
(macros-only-env-4547
-                                                                     
er-31155))))
+                                                       (let ((er-31378
+                                                               (car (cdr 
b-31373))))
+                                                         (let ((r-cache-31379
+                                                                 (if (eq? 
er-31378
+                                                                          
er-cache-31371)
+                                                                   
r-cache-31372
+                                                                   
(macros-only-env-4343
+                                                                     
er-31378))))
                                                            (begin
                                                              (set-cdr!
-                                                               b-31150
-                                                               
(eval-local-transformer-4592
-                                                                 (expand-4586
-                                                                   (cdr (cdr 
b-31150))
-                                                                   
r-cache-31156
+                                                               b-31373
+                                                               
(eval-local-transformer-4388
+                                                                 (expand-4382
+                                                                   (cdr (cdr 
b-31373))
+                                                                   
r-cache-31379
                                                                    '(())
-                                                                   mod-29711)
-                                                                 mod-29711))
-                                                             (if (eq? (car 
b-31150)
+                                                                   mod-29921)
+                                                                 mod-29921))
+                                                             (if (eq? (car 
b-31373)
                                                                       
'syntax-parameter)
                                                                (set-cdr!
-                                                                 b-31150
-                                                                 (list (cdr 
b-31150))))
-                                                             (loop-31144
-                                                               (cdr bs-31147)
-                                                               er-31155
-                                                               
r-cache-31156))))
-                                                       (loop-31144
-                                                         (cdr bs-31147)
-                                                         er-cache-31148
-                                                         r-cache-31149)))))))
-                                            (loop-31144 bindings-29515 #f #f))
+                                                                 b-31373
+                                                                 (list (cdr 
b-31373))))
+                                                             (loop-31367
+                                                               (cdr bs-31370)
+                                                               er-31378
+                                                               
r-cache-31379))))
+                                                       (loop-31367
+                                                         (cdr bs-31370)
+                                                         er-cache-31371
+                                                         r-cache-31372)))))))
+                                            (loop-31367 bindings-29725 #f #f))
                                           (set-cdr!
-                                            r-29398
-                                            (extend-env-4545
-                                              labels-29511
-                                              bindings-29515
-                                              (cdr r-29398)))
-                                          (build-letrec-4535
+                                            r-29608
+                                            (extend-env-4341
+                                              labels-29721
+                                              bindings-29725
+                                              (cdr r-29608)))
+                                          (build-letrec-4331
                                             #f
                                             #t
                                             (reverse
                                               (map syntax->datum
-                                                   var-ids-29512))
-                                            (reverse vars-29513)
-                                            (map (lambda (x-31576)
-                                                   (expand-4586
-                                                     (cdr x-31576)
-                                                     (car x-31576)
+                                                   var-ids-29722))
+                                            (reverse vars-29723)
+                                            (map (lambda (x-31799)
+                                                   (expand-4382
+                                                     (cdr x-31799)
+                                                     (car x-31799)
                                                      '(())
-                                                     mod-29711))
-                                                 (reverse vals-29514))
-                                            (build-sequence-4532
+                                                     mod-29921))
+                                                 (reverse vals-29724))
+                                            (build-sequence-4328
                                               #f
-                                              (map (lambda (x-31712)
-                                                     (expand-4586
-                                                       (cdr x-31712)
-                                                       (car x-31712)
+                                              (map (lambda (x-31935)
+                                                     (expand-4382
+                                                       (cdr x-31935)
+                                                       (car x-31935)
                                                        '(())
-                                                       mod-29711))
-                                                   (cons (cons er-29517
-                                                               (let ((x-31787
+                                                       mod-29921))
+                                                   (cons (cons er-29727
+                                                               (let ((x-32010
                                                                        (begin
-                                                                         (if 
(if (pair? e-29708)
-                                                                               
s-29710
+                                                                         (if 
(if (pair? e-29918)
+                                                                               
s-29920
                                                                                
#f)
                                                                            
(set-source-properties!
-                                                                             
e-29708
-                                                                             
s-29710))
-                                                                         
e-29708)))
-                                                                 (if (if 
(null? (car w-29709))
-                                                                       (null? 
(cdr w-29709))
+                                                                             
e-29918
+                                                                             
s-29920))
+                                                                         
e-29918)))
+                                                                 (if (if 
(null? (car w-29919))
+                                                                       (null? 
(cdr w-29919))
                                                                        #f)
-                                                                   x-31787
+                                                                   x-32010
                                                                    (if (if 
(vector?
-                                                                             
x-31787)
+                                                                             
x-32010)
                                                                          (if 
(= (vector-length
-                                                                               
   x-31787)
+                                                                               
   x-32010)
                                                                                
 4)
                                                                            
(eq? (vector-ref
-                                                                               
   x-31787
+                                                                               
   x-32010
                                                                                
   0)
                                                                                
 'syntax-object)
                                                                            #f)
                                                                          #f)
-                                                                     (let 
((expression-31819
+                                                                     (let 
((expression-32042
                                                                              
(vector-ref
-                                                                               
x-31787
+                                                                               
x-32010
                                                                                
1))
-                                                                           
(wrap-31820
-                                                                             
(let ((w2-31828
+                                                                           
(wrap-32043
+                                                                             
(let ((w2-32051
                                                                                
      (vector-ref
-                                                                               
        x-31787
+                                                                               
        x-32010
                                                                                
        2)))
-                                                                               
(let ((m1-31829
-                                                                               
        (car w-29709))
-                                                                               
      (s1-31830
-                                                                               
        (cdr w-29709)))
-                                                                               
  (if (null? m1-31829)
-                                                                               
    (if (null? s1-31830)
-                                                                               
      w2-31828
-                                                                               
      (cons (car w2-31828)
-                                                                               
            (let ((m2-31845
-                                                                               
                    (cdr w2-31828)))
-                                                                               
              (if (null? m2-31845)
-                                                                               
                s1-31830
+                                                                               
(let ((m1-32052
+                                                                               
        (car w-29919))
+                                                                               
      (s1-32053
+                                                                               
        (cdr w-29919)))
+                                                                               
  (if (null? m1-32052)
+                                                                               
    (if (null? s1-32053)
+                                                                               
      w2-32051
+                                                                               
      (cons (car w2-32051)
+                                                                               
            (let ((m2-32068
+                                                                               
                    (cdr w2-32051)))
+                                                                               
              (if (null? m2-32068)
+                                                                               
                s1-32053
                                                                                
                (append
-                                                                               
                  s1-31830
-                                                                               
                  m2-31845)))))
-                                                                               
    (cons (let ((m2-31853
-                                                                               
                  (car w2-31828)))
-                                                                               
            (if (null? m2-31853)
-                                                                               
              m1-31829
+                                                                               
                  s1-32053
+                                                                               
                  m2-32068)))))
+                                                                               
    (cons (let ((m2-32076
+                                                                               
                  (car w2-32051)))
+                                                                               
            (if (null? m2-32076)
+                                                                               
              m1-32052
                                                                                
              (append
-                                                                               
                m1-31829
-                                                                               
                m2-31853)))
-                                                                               
          (let ((m2-31861
-                                                                               
                  (cdr w2-31828)))
-                                                                               
            (if (null? m2-31861)
-                                                                               
              s1-31830
+                                                                               
                m1-32052
+                                                                               
                m2-32076)))
+                                                                               
          (let ((m2-32084
+                                                                               
                  (cdr w2-32051)))
+                                                                               
            (if (null? m2-32084)
+                                                                               
              s1-32053
                                                                                
              (append
-                                                                               
                s1-31830
-                                                                               
                m2-31861))))))))
-                                                                           
(module-31821
+                                                                               
                s1-32053
+                                                                               
                m2-32084))))))))
+                                                                           
(module-32044
                                                                              
(vector-ref
-                                                                               
x-31787
+                                                                               
x-32010
                                                                                
3)))
                                                                        (vector
                                                                          
'syntax-object
-                                                                         
expression-31819
-                                                                         
wrap-31820
-                                                                         
module-31821))
-                                                                     (if 
(null? x-31787)
-                                                                       x-31787
+                                                                         
expression-32042
+                                                                         
wrap-32043
+                                                                         
module-32044))
+                                                                     (if 
(null? x-32010)
+                                                                       x-32010
                                                                        (vector
                                                                          
'syntax-object
-                                                                         
x-31787
-                                                                         
w-29709
-                                                                         
mod-29711))))))
-                                                         (cdr 
body-29509))))))))))))))))))
-                 (parse-29401
-                   (map (lambda (x-29404)
-                          (cons r-29398
-                                (if (if (null? (car w-29400))
-                                      (null? (cdr w-29400))
+                                                                         
x-32010
+                                                                         
w-29919
+                                                                         
mod-29921))))))
+                                                         (cdr 
body-29719))))))))))))))))))
+                 (parse-29611
+                   (map (lambda (x-29614)
+                          (cons r-29608
+                                (if (if (null? (car w-29610))
+                                      (null? (cdr w-29610))
                                       #f)
-                                  x-29404
-                                  (if (if (vector? x-29404)
-                                        (if (= (vector-length x-29404) 4)
-                                          (eq? (vector-ref x-29404 0)
+                                  x-29614
+                                  (if (if (vector? x-29614)
+                                        (if (= (vector-length x-29614) 4)
+                                          (eq? (vector-ref x-29614 0)
                                                'syntax-object)
                                           #f)
                                         #f)
-                                    (let ((expression-29440
-                                            (vector-ref x-29404 1))
-                                          (wrap-29441
-                                            (let ((w2-29451
-                                                    (vector-ref x-29404 2)))
-                                              (let ((m1-29452 (car w-29400))
-                                                    (s1-29453 (cdr w-29400)))
-                                                (if (null? m1-29452)
-                                                  (if (null? s1-29453)
-                                                    w2-29451
-                                                    (cons (car w2-29451)
-                                                          (let ((m2-29470
-                                                                  (cdr 
w2-29451)))
-                                                            (if (null? 
m2-29470)
-                                                              s1-29453
+                                    (let ((expression-29650
+                                            (vector-ref x-29614 1))
+                                          (wrap-29651
+                                            (let ((w2-29661
+                                                    (vector-ref x-29614 2)))
+                                              (let ((m1-29662 (car w-29610))
+                                                    (s1-29663 (cdr w-29610)))
+                                                (if (null? m1-29662)
+                                                  (if (null? s1-29663)
+                                                    w2-29661
+                                                    (cons (car w2-29661)
+                                                          (let ((m2-29680
+                                                                  (cdr 
w2-29661)))
+                                                            (if (null? 
m2-29680)
+                                                              s1-29663
                                                               (append
-                                                                s1-29453
-                                                                m2-29470)))))
-                                                  (cons (let ((m2-29478
-                                                                (car 
w2-29451)))
-                                                          (if (null? m2-29478)
-                                                            m1-29452
+                                                                s1-29663
+                                                                m2-29680)))))
+                                                  (cons (let ((m2-29688
+                                                                (car 
w2-29661)))
+                                                          (if (null? m2-29688)
+                                                            m1-29662
                                                             (append
-                                                              m1-29452
-                                                              m2-29478)))
-                                                        (let ((m2-29486
-                                                                (cdr 
w2-29451)))
-                                                          (if (null? m2-29486)
-                                                            s1-29453
+                                                              m1-29662
+                                                              m2-29688)))
+                                                        (let ((m2-29696
+                                                                (cdr 
w2-29661)))
+                                                          (if (null? m2-29696)
+                                                            s1-29663
                                                             (append
-                                                              s1-29453
-                                                              m2-29486))))))))
-                                          (module-29442
-                                            (vector-ref x-29404 3)))
+                                                              s1-29663
+                                                              m2-29696))))))))
+                                          (module-29652
+                                            (vector-ref x-29614 3)))
                                       (vector
                                         'syntax-object
-                                        expression-29440
-                                        wrap-29441
-                                        module-29442))
-                                    (if (null? x-29404)
-                                      x-29404
+                                        expression-29650
+                                        wrap-29651
+                                        module-29652))
+                                    (if (null? x-29614)
+                                      x-29614
                                       (vector
                                         'syntax-object
-                                        x-29404
-                                        w-29400
-                                        mod-29397))))))
-                        body-29393)
+                                        x-29614
+                                        w-29610
+                                        mod-29607))))))
+                        body-29603)
                    '()
                    '()
                    '()
                    '()
                    '()
                    '())))))))
-     (expand-local-syntax-4591
-       (lambda (rec?-31876
-                e-31877
-                r-31878
-                w-31879
-                s-31880
-                mod-31881
-                k-31882)
-         (let ((tmp-31884
+     (expand-local-syntax-4387
+       (lambda (rec?-32099
+                e-32100
+                r-32101
+                w-32102
+                s-32103
+                mod-32104
+                k-32105)
+         (let ((tmp-32107
                  ($sc-dispatch
-                   e-31877
+                   e-32100
                    '(_ #(each (any any)) any . each-any))))
-           (if tmp-31884
+           (if tmp-32107
              (@apply
-               (lambda (id-31888 val-31889 e1-31890 e2-31891)
-                 (if (not (valid-bound-ids?-4576 id-31888))
+               (lambda (id-32111 val-32112 e1-32113 e2-32114)
+                 (if (not (valid-bound-ids?-4372 id-32111))
                    (syntax-violation
                      #f
                      "duplicate bound keyword"
-                     e-31877)
-                   (let ((labels-31988 (gen-labels-4553 id-31888)))
-                     (let ((new-w-31989
-                             (make-binding-wrap-4564
-                               id-31888
-                               labels-31988
-                               w-31879)))
-                       (k-31882
-                         (cons e1-31890 e2-31891)
-                         (extend-env-4545
-                           labels-31988
-                           (let ((trans-r-32027
-                                   (macros-only-env-4547 r-31878)))
+                     e-32100)
+                   (let ((labels-32211 (gen-labels-4349 id-32111)))
+                     (let ((new-w-32212
+                             (make-binding-wrap-4360
+                               id-32111
+                               labels-32211
+                               w-32102)))
+                       (k-32105
+                         (cons e1-32113 e2-32114)
+                         (extend-env-4341
+                           labels-32211
+                           (let ((trans-r-32250
+                                   (macros-only-env-4343 r-32101)))
                              (begin
-                               (if rec?-31876 new-w-31989 w-31879)
-                               (map (lambda (x-32028)
+                               (if rec?-32099 new-w-32212 w-32102)
+                               (map (lambda (x-32251)
                                       (cons 'macro
-                                            (eval-local-transformer-4592
-                                              (expand-4586
-                                                x-32028
-                                                trans-r-32027
+                                            (eval-local-transformer-4388
+                                              (expand-4382
+                                                x-32251
+                                                trans-r-32250
                                                 (values
-                                                  (if rec?-31876
-                                                    new-w-31989
-                                                    w-31879))
-                                                mod-31881)
-                                              mod-31881)))
-                                    val-31889)))
-                           r-31878)
-                         new-w-31989
-                         s-31880
-                         mod-31881)))))
-               tmp-31884)
+                                                  (if rec?-32099
+                                                    new-w-32212
+                                                    w-32102))
+                                                mod-32104)
+                                              mod-32104)))
+                                    val-32112)))
+                           r-32101)
+                         new-w-32212
+                         s-32103
+                         mod-32104)))))
+               tmp-32107)
              (syntax-violation
                #f
                "bad local syntax definition"
-               (let ((x-32335
+               (let ((x-32558
                        (begin
-                         (if (if (pair? e-31877) s-31880 #f)
-                           (set-source-properties! e-31877 s-31880))
-                         e-31877)))
-                 (if (if (null? (car w-31879))
-                       (null? (cdr w-31879))
+                         (if (if (pair? e-32100) s-32103 #f)
+                           (set-source-properties! e-32100 s-32103))
+                         e-32100)))
+                 (if (if (null? (car w-32102))
+                       (null? (cdr w-32102))
                        #f)
-                   x-32335
-                   (if (if (vector? x-32335)
-                         (if (= (vector-length x-32335) 4)
-                           (eq? (vector-ref x-32335 0) 'syntax-object)
+                   x-32558
+                   (if (if (vector? x-32558)
+                         (if (= (vector-length x-32558) 4)
+                           (eq? (vector-ref x-32558 0) 'syntax-object)
                            #f)
                          #f)
-                     (let ((expression-32367 (vector-ref x-32335 1))
-                           (wrap-32368
-                             (let ((w2-32376 (vector-ref x-32335 2)))
-                               (let ((m1-32377 (car w-31879))
-                                     (s1-32378 (cdr w-31879)))
-                                 (if (null? m1-32377)
-                                   (if (null? s1-32378)
-                                     w2-32376
-                                     (cons (car w2-32376)
-                                           (let ((m2-32393 (cdr w2-32376)))
-                                             (if (null? m2-32393)
-                                               s1-32378
-                                               (append s1-32378 m2-32393)))))
-                                   (cons (let ((m2-32401 (car w2-32376)))
-                                           (if (null? m2-32401)
-                                             m1-32377
-                                             (append m1-32377 m2-32401)))
-                                         (let ((m2-32409 (cdr w2-32376)))
-                                           (if (null? m2-32409)
-                                             s1-32378
-                                             (append s1-32378 m2-32409))))))))
-                           (module-32369 (vector-ref x-32335 3)))
+                     (let ((expression-32590 (vector-ref x-32558 1))
+                           (wrap-32591
+                             (let ((w2-32599 (vector-ref x-32558 2)))
+                               (let ((m1-32600 (car w-32102))
+                                     (s1-32601 (cdr w-32102)))
+                                 (if (null? m1-32600)
+                                   (if (null? s1-32601)
+                                     w2-32599
+                                     (cons (car w2-32599)
+                                           (let ((m2-32616 (cdr w2-32599)))
+                                             (if (null? m2-32616)
+                                               s1-32601
+                                               (append s1-32601 m2-32616)))))
+                                   (cons (let ((m2-32624 (car w2-32599)))
+                                           (if (null? m2-32624)
+                                             m1-32600
+                                             (append m1-32600 m2-32624)))
+                                         (let ((m2-32632 (cdr w2-32599)))
+                                           (if (null? m2-32632)
+                                             s1-32601
+                                             (append s1-32601 m2-32632))))))))
+                           (module-32592 (vector-ref x-32558 3)))
                        (vector
                          'syntax-object
-                         expression-32367
-                         wrap-32368
-                         module-32369))
-                     (if (null? x-32335)
-                       x-32335
+                         expression-32590
+                         wrap-32591
+                         module-32592))
+                     (if (null? x-32558)
+                       x-32558
                        (vector
                          'syntax-object
-                         x-32335
-                         w-31879
-                         mod-31881))))))))))
-     (eval-local-transformer-4592
-       (lambda (expanded-32427 mod-32428)
-         (let ((p-32429 (primitive-eval expanded-32427)))
-           (if (procedure? p-32429)
-             p-32429
+                         x-32558
+                         w-32102
+                         mod-32104))))))))))
+     (eval-local-transformer-4388
+       (lambda (expanded-32650 mod-32651)
+         (let ((p-32652 (primitive-eval expanded-32650)))
+           (if (procedure? p-32652)
+             p-32652
              (syntax-violation
                #f
                "nonprocedure transformer"
-               p-32429)))))
-     (ellipsis?-4594
-       (lambda (x-6134)
-         (if (if (if (vector? x-6134)
-                   (if (= (vector-length x-6134) 4)
-                     (eq? (vector-ref x-6134 0) 'syntax-object)
+               p-32652)))))
+     (ellipsis?-4390
+       (lambda (x-5943)
+         (if (if (if (vector? x-5943)
+                   (if (= (vector-length x-5943) 4)
+                     (eq? (vector-ref x-5943 0) 'syntax-object)
                      #f)
                    #f)
-               (symbol? (vector-ref x-6134 1))
+               (symbol? (vector-ref x-5943 1))
                #f)
-           (free-id=?-4574
-             x-6134
+           (free-id=?-4370
+             x-5943
              '#(syntax-object
                 ...
                 ((top)
                  #(ribcage () () ())
                  #(ribcage () () ())
-                 #(ribcage #(x) #((top)) #("l-*-2416"))
+                 #(ribcage #(x) #((top)) #("l-*-2324"))
                  #(ribcage
                    (lambda-var-list
                      gen-var
@@ -7004,315 +7021,315 @@
                  #(ribcage () () ()))
                 (hygiene guile)))
            #f)))
-     (lambda-formals-4595
-       (lambda (orig-args-32434)
+     (lambda-formals-4391
+       (lambda (orig-args-32657)
          (letrec*
-           ((req-32435
-              (lambda (args-32439 rreq-32440)
-                (let ((tmp-32442 ($sc-dispatch args-32439 '())))
-                  (if tmp-32442
+           ((req-32658
+              (lambda (args-32662 rreq-32663)
+                (let ((tmp-32665 ($sc-dispatch args-32662 '())))
+                  (if tmp-32665
                     (@apply
-                      (lambda () (check-32436 (reverse rreq-32440) #f))
-                      tmp-32442)
-                    (let ((tmp-32558
-                            ($sc-dispatch args-32439 '(any . any))))
-                      (if (if tmp-32558
+                      (lambda () (check-32659 (reverse rreq-32663) #f))
+                      tmp-32665)
+                    (let ((tmp-32781
+                            ($sc-dispatch args-32662 '(any . any))))
+                      (if (if tmp-32781
                             (@apply
-                              (lambda (a-32562 b-32563)
-                                (if (symbol? a-32562)
+                              (lambda (a-32785 b-32786)
+                                (if (symbol? a-32785)
                                   #t
-                                  (if (if (vector? a-32562)
-                                        (if (= (vector-length a-32562) 4)
-                                          (eq? (vector-ref a-32562 0)
+                                  (if (if (vector? a-32785)
+                                        (if (= (vector-length a-32785) 4)
+                                          (eq? (vector-ref a-32785 0)
                                                'syntax-object)
                                           #f)
                                         #f)
-                                    (symbol? (vector-ref a-32562 1))
+                                    (symbol? (vector-ref a-32785 1))
                                     #f)))
-                              tmp-32558)
+                              tmp-32781)
                             #f)
                         (@apply
-                          (lambda (a-32590 b-32591)
-                            (req-32435 b-32591 (cons a-32590 rreq-32440)))
-                          tmp-32558)
-                        (let ((tmp-32592 (list args-32439)))
+                          (lambda (a-32813 b-32814)
+                            (req-32658 b-32814 (cons a-32813 rreq-32663)))
+                          tmp-32781)
+                        (let ((tmp-32815 (list args-32662)))
                           (if (@apply
-                                (lambda (r-32594)
-                                  (if (symbol? r-32594)
+                                (lambda (r-32817)
+                                  (if (symbol? r-32817)
                                     #t
-                                    (if (if (vector? r-32594)
-                                          (if (= (vector-length r-32594) 4)
-                                            (eq? (vector-ref r-32594 0)
+                                    (if (if (vector? r-32817)
+                                          (if (= (vector-length r-32817) 4)
+                                            (eq? (vector-ref r-32817 0)
                                                  'syntax-object)
                                             #f)
                                           #f)
-                                      (symbol? (vector-ref r-32594 1))
+                                      (symbol? (vector-ref r-32817 1))
                                       #f)))
-                                tmp-32592)
+                                tmp-32815)
                             (@apply
-                              (lambda (r-32624)
-                                (check-32436 (reverse rreq-32440) r-32624))
-                              tmp-32592)
+                              (lambda (r-32847)
+                                (check-32659 (reverse rreq-32663) r-32847))
+                              tmp-32815)
                             (syntax-violation
                               'lambda
                               "invalid argument list"
-                              orig-args-32434
-                              args-32439)))))))))
-            (check-32436
-              (lambda (req-32748 rest-32749)
-                (if (distinct-bound-ids?-4577
-                      (if rest-32749
-                        (cons rest-32749 req-32748)
-                        req-32748))
-                  (values req-32748 #f rest-32749 #f)
+                              orig-args-32657
+                              args-32662)))))))))
+            (check-32659
+              (lambda (req-32971 rest-32972)
+                (if (distinct-bound-ids?-4373
+                      (if rest-32972
+                        (cons rest-32972 req-32971)
+                        req-32971))
+                  (values req-32971 #f rest-32972 #f)
                   (syntax-violation
                     'lambda
                     "duplicate identifier in argument list"
-                    orig-args-32434)))))
-           (req-32435 orig-args-32434 '()))))
-     (expand-simple-lambda-4596
-       (lambda (e-32858
-                r-32859
-                w-32860
-                s-32861
-                mod-32862
-                req-32863
-                rest-32864
-                meta-32865
-                body-32866)
-         (let ((ids-32867
-                 (if rest-32864
-                   (append req-32863 (list rest-32864))
-                   req-32863)))
-           (let ((vars-32868 (map gen-var-4600 ids-32867)))
-             (let ((labels-32869 (gen-labels-4553 ids-32867)))
-               (build-simple-lambda-4526
-                 s-32861
-                 (map syntax->datum req-32863)
-                 (if rest-32864 (syntax->datum rest-32864) #f)
-                 vars-32868
-                 meta-32865
-                 (expand-body-4590
-                   body-32866
-                   (let ((x-33052
+                    orig-args-32657)))))
+           (req-32658 orig-args-32657 '()))))
+     (expand-simple-lambda-4392
+       (lambda (e-33081
+                r-33082
+                w-33083
+                s-33084
+                mod-33085
+                req-33086
+                rest-33087
+                meta-33088
+                body-33089)
+         (let ((ids-33090
+                 (if rest-33087
+                   (append req-33086 (list rest-33087))
+                   req-33086)))
+           (let ((vars-33091 (map gen-var-4396 ids-33090)))
+             (let ((labels-33092 (gen-labels-4349 ids-33090)))
+               (build-simple-lambda-4322
+                 s-33084
+                 (map syntax->datum req-33086)
+                 (if rest-33087 (syntax->datum rest-33087) #f)
+                 vars-33091
+                 meta-33088
+                 (expand-body-4386
+                   body-33089
+                   (let ((x-33275
                            (begin
-                             (if (if (pair? e-32858) s-32861 #f)
-                               (set-source-properties! e-32858 s-32861))
-                             e-32858)))
-                     (if (if (null? (car w-32860))
-                           (null? (cdr w-32860))
+                             (if (if (pair? e-33081) s-33084 #f)
+                               (set-source-properties! e-33081 s-33084))
+                             e-33081)))
+                     (if (if (null? (car w-33083))
+                           (null? (cdr w-33083))
                            #f)
-                       x-33052
-                       (if (if (vector? x-33052)
-                             (if (= (vector-length x-33052) 4)
-                               (eq? (vector-ref x-33052 0) 'syntax-object)
+                       x-33275
+                       (if (if (vector? x-33275)
+                             (if (= (vector-length x-33275) 4)
+                               (eq? (vector-ref x-33275 0) 'syntax-object)
                                #f)
                              #f)
-                         (let ((expression-33084 (vector-ref x-33052 1))
-                               (wrap-33085
-                                 (let ((w2-33093 (vector-ref x-33052 2)))
-                                   (let ((m1-33094 (car w-32860))
-                                         (s1-33095 (cdr w-32860)))
-                                     (if (null? m1-33094)
-                                       (if (null? s1-33095)
-                                         w2-33093
-                                         (cons (car w2-33093)
-                                               (let ((m2-33110 (cdr w2-33093)))
-                                                 (if (null? m2-33110)
-                                                   s1-33095
+                         (let ((expression-33307 (vector-ref x-33275 1))
+                               (wrap-33308
+                                 (let ((w2-33316 (vector-ref x-33275 2)))
+                                   (let ((m1-33317 (car w-33083))
+                                         (s1-33318 (cdr w-33083)))
+                                     (if (null? m1-33317)
+                                       (if (null? s1-33318)
+                                         w2-33316
+                                         (cons (car w2-33316)
+                                               (let ((m2-33333 (cdr w2-33316)))
+                                                 (if (null? m2-33333)
+                                                   s1-33318
                                                    (append
-                                                     s1-33095
-                                                     m2-33110)))))
-                                       (cons (let ((m2-33118 (car w2-33093)))
-                                               (if (null? m2-33118)
-                                                 m1-33094
-                                                 (append m1-33094 m2-33118)))
-                                             (let ((m2-33126 (cdr w2-33093)))
-                                               (if (null? m2-33126)
-                                                 s1-33095
+                                                     s1-33318
+                                                     m2-33333)))))
+                                       (cons (let ((m2-33341 (car w2-33316)))
+                                               (if (null? m2-33341)
+                                                 m1-33317
+                                                 (append m1-33317 m2-33341)))
+                                             (let ((m2-33349 (cdr w2-33316)))
+                                               (if (null? m2-33349)
+                                                 s1-33318
                                                  (append
-                                                   s1-33095
-                                                   m2-33126))))))))
-                               (module-33086 (vector-ref x-33052 3)))
+                                                   s1-33318
+                                                   m2-33349))))))))
+                               (module-33309 (vector-ref x-33275 3)))
                            (vector
                              'syntax-object
-                             expression-33084
-                             wrap-33085
-                             module-33086))
-                         (if (null? x-33052)
-                           x-33052
+                             expression-33307
+                             wrap-33308
+                             module-33309))
+                         (if (null? x-33275)
+                           x-33275
                            (vector
                              'syntax-object
-                             x-33052
-                             w-32860
-                             mod-32862)))))
-                   (extend-var-env-4546
-                     labels-32869
-                     vars-32868
-                     r-32859)
-                   (make-binding-wrap-4564
-                     ids-32867
-                     labels-32869
-                     w-32860)
-                   mod-32862)))))))
-     (lambda*-formals-4597
-       (lambda (orig-args-33335)
+                             x-33275
+                             w-33083
+                             mod-33085)))))
+                   (extend-var-env-4342
+                     labels-33092
+                     vars-33091
+                     r-33082)
+                   (make-binding-wrap-4360
+                     ids-33090
+                     labels-33092
+                     w-33083)
+                   mod-33085)))))))
+     (lambda*-formals-4393
+       (lambda (orig-args-33558)
          (letrec*
-           ((req-33336
-              (lambda (args-33343 rreq-33344)
-                (let ((tmp-33346 ($sc-dispatch args-33343 '())))
-                  (if tmp-33346
+           ((req-33559
+              (lambda (args-33566 rreq-33567)
+                (let ((tmp-33569 ($sc-dispatch args-33566 '())))
+                  (if tmp-33569
                     (@apply
                       (lambda ()
-                        (check-33340 (reverse rreq-33344) '() #f '()))
-                      tmp-33346)
-                    (let ((tmp-33465
-                            ($sc-dispatch args-33343 '(any . any))))
-                      (if (if tmp-33465
+                        (check-33563 (reverse rreq-33567) '() #f '()))
+                      tmp-33569)
+                    (let ((tmp-33688
+                            ($sc-dispatch args-33566 '(any . any))))
+                      (if (if tmp-33688
                             (@apply
-                              (lambda (a-33469 b-33470)
-                                (if (symbol? a-33469)
+                              (lambda (a-33692 b-33693)
+                                (if (symbol? a-33692)
                                   #t
-                                  (if (if (vector? a-33469)
-                                        (if (= (vector-length a-33469) 4)
-                                          (eq? (vector-ref a-33469 0)
+                                  (if (if (vector? a-33692)
+                                        (if (= (vector-length a-33692) 4)
+                                          (eq? (vector-ref a-33692 0)
                                                'syntax-object)
                                           #f)
                                         #f)
-                                    (symbol? (vector-ref a-33469 1))
+                                    (symbol? (vector-ref a-33692 1))
                                     #f)))
-                              tmp-33465)
+                              tmp-33688)
                             #f)
                         (@apply
-                          (lambda (a-33497 b-33498)
-                            (req-33336 b-33498 (cons a-33497 rreq-33344)))
-                          tmp-33465)
-                        (let ((tmp-33499
-                                ($sc-dispatch args-33343 '(any . any))))
-                          (if (if tmp-33499
+                          (lambda (a-33720 b-33721)
+                            (req-33559 b-33721 (cons a-33720 rreq-33567)))
+                          tmp-33688)
+                        (let ((tmp-33722
+                                ($sc-dispatch args-33566 '(any . any))))
+                          (if (if tmp-33722
                                 (@apply
-                                  (lambda (a-33503 b-33504)
-                                    (eq? (syntax->datum a-33503) #:optional))
-                                  tmp-33499)
+                                  (lambda (a-33726 b-33727)
+                                    (eq? (syntax->datum a-33726) #:optional))
+                                  tmp-33722)
                                 #f)
                             (@apply
-                              (lambda (a-33505 b-33506)
-                                (opt-33337 b-33506 (reverse rreq-33344) '()))
-                              tmp-33499)
-                            (let ((tmp-33509
-                                    ($sc-dispatch args-33343 '(any . any))))
-                              (if (if tmp-33509
+                              (lambda (a-33728 b-33729)
+                                (opt-33560 b-33729 (reverse rreq-33567) '()))
+                              tmp-33722)
+                            (let ((tmp-33732
+                                    ($sc-dispatch args-33566 '(any . any))))
+                              (if (if tmp-33732
                                     (@apply
-                                      (lambda (a-33513 b-33514)
-                                        (eq? (syntax->datum a-33513) #:key))
-                                      tmp-33509)
+                                      (lambda (a-33736 b-33737)
+                                        (eq? (syntax->datum a-33736) #:key))
+                                      tmp-33732)
                                     #f)
                                 (@apply
-                                  (lambda (a-33515 b-33516)
-                                    (key-33338
-                                      b-33516
-                                      (reverse rreq-33344)
+                                  (lambda (a-33738 b-33739)
+                                    (key-33561
+                                      b-33739
+                                      (reverse rreq-33567)
                                       '()
                                       '()))
-                                  tmp-33509)
-                                (let ((tmp-33519
-                                        ($sc-dispatch args-33343 '(any any))))
-                                  (if (if tmp-33519
+                                  tmp-33732)
+                                (let ((tmp-33742
+                                        ($sc-dispatch args-33566 '(any any))))
+                                  (if (if tmp-33742
                                         (@apply
-                                          (lambda (a-33523 b-33524)
-                                            (eq? (syntax->datum a-33523)
+                                          (lambda (a-33746 b-33747)
+                                            (eq? (syntax->datum a-33746)
                                                  #:rest))
-                                          tmp-33519)
+                                          tmp-33742)
                                         #f)
                                     (@apply
-                                      (lambda (a-33525 b-33526)
-                                        (rest-33339
-                                          b-33526
-                                          (reverse rreq-33344)
+                                      (lambda (a-33748 b-33749)
+                                        (rest-33562
+                                          b-33749
+                                          (reverse rreq-33567)
                                           '()
                                           '()))
-                                      tmp-33519)
-                                    (let ((tmp-33529 (list args-33343)))
+                                      tmp-33742)
+                                    (let ((tmp-33752 (list args-33566)))
                                       (if (@apply
-                                            (lambda (r-33531)
-                                              (if (symbol? r-33531)
+                                            (lambda (r-33754)
+                                              (if (symbol? r-33754)
                                                 #t
-                                                (if (if (vector? r-33531)
+                                                (if (if (vector? r-33754)
                                                       (if (= (vector-length
-                                                               r-33531)
+                                                               r-33754)
                                                              4)
                                                         (eq? (vector-ref
-                                                               r-33531
+                                                               r-33754
                                                                0)
                                                              'syntax-object)
                                                         #f)
                                                       #f)
                                                   (symbol?
-                                                    (vector-ref r-33531 1))
+                                                    (vector-ref r-33754 1))
                                                   #f)))
-                                            tmp-33529)
+                                            tmp-33752)
                                         (@apply
-                                          (lambda (r-33561)
-                                            (rest-33339
-                                              r-33561
-                                              (reverse rreq-33344)
+                                          (lambda (r-33784)
+                                            (rest-33562
+                                              r-33784
+                                              (reverse rreq-33567)
                                               '()
                                               '()))
-                                          tmp-33529)
+                                          tmp-33752)
                                         (syntax-violation
                                           'lambda*
                                           "invalid argument list"
-                                          orig-args-33335
-                                          args-33343)))))))))))))))
-            (opt-33337
-              (lambda (args-33580 req-33581 ropt-33582)
-                (let ((tmp-33584 ($sc-dispatch args-33580 '())))
-                  (if tmp-33584
+                                          orig-args-33558
+                                          args-33566)))))))))))))))
+            (opt-33560
+              (lambda (args-33803 req-33804 ropt-33805)
+                (let ((tmp-33807 ($sc-dispatch args-33803 '())))
+                  (if tmp-33807
                     (@apply
                       (lambda ()
-                        (check-33340
-                          req-33581
-                          (reverse ropt-33582)
+                        (check-33563
+                          req-33804
+                          (reverse ropt-33805)
                           #f
                           '()))
-                      tmp-33584)
-                    (let ((tmp-33705
-                            ($sc-dispatch args-33580 '(any . any))))
-                      (if (if tmp-33705
+                      tmp-33807)
+                    (let ((tmp-33928
+                            ($sc-dispatch args-33803 '(any . any))))
+                      (if (if tmp-33928
                             (@apply
-                              (lambda (a-33709 b-33710)
-                                (if (symbol? a-33709)
+                              (lambda (a-33932 b-33933)
+                                (if (symbol? a-33932)
                                   #t
-                                  (if (if (vector? a-33709)
-                                        (if (= (vector-length a-33709) 4)
-                                          (eq? (vector-ref a-33709 0)
+                                  (if (if (vector? a-33932)
+                                        (if (= (vector-length a-33932) 4)
+                                          (eq? (vector-ref a-33932 0)
                                                'syntax-object)
                                           #f)
                                         #f)
-                                    (symbol? (vector-ref a-33709 1))
+                                    (symbol? (vector-ref a-33932 1))
                                     #f)))
-                              tmp-33705)
+                              tmp-33928)
                             #f)
                         (@apply
-                          (lambda (a-33737 b-33738)
-                            (opt-33337
-                              b-33738
-                              req-33581
-                              (cons (cons a-33737
+                          (lambda (a-33960 b-33961)
+                            (opt-33560
+                              b-33961
+                              req-33804
+                              (cons (cons a-33960
                                           '(#(syntax-object
                                               #f
                                               ((top)
                                                #(ribcage
                                                  #(a b)
                                                  #((top) (top))
-                                                 #("l-*-2555" "l-*-2556"))
+                                                 #("l-*-2461" "l-*-2462"))
                                                #(ribcage () () ())
                                                #(ribcage
                                                  #(args req ropt)
                                                  #((top) (top) (top))
-                                                 #("l-*-2545"
-                                                   "l-*-2546"
-                                                   "l-*-2547"))
+                                                 #("l-*-2451"
+                                                   "l-*-2452"
+                                                   "l-*-2453"))
                                                #(ribcage
                                                  (check rest key opt req)
                                                  ((top)
@@ -7320,15 +7337,15 @@
                                                   (top)
                                                   (top)
                                                   (top))
-                                                 ("l-*-2491"
-                                                  "l-*-2489"
-                                                  "l-*-2487"
-                                                  "l-*-2485"
-                                                  "l-*-2483"))
+                                                 ("l-*-2397"
+                                                  "l-*-2395"
+                                                  "l-*-2393"
+                                                  "l-*-2391"
+                                                  "l-*-2389"))
                                                #(ribcage
                                                  #(orig-args)
                                                  #((top))
-                                                 #("l-*-2482"))
+                                                 #("l-*-2388"))
                                                #(ribcage
                                                  (lambda-var-list
                                                    gen-var
@@ -7761,136 +7778,136 @@
                                                  ("l-*-47" "l-*-46" "l-*-45"))
                                                #(ribcage () () ()))
                                               (hygiene guile))))
-                                    ropt-33582)))
-                          tmp-33705)
-                        (let ((tmp-33739
-                                ($sc-dispatch args-33580 '((any any) . any))))
-                          (if (if tmp-33739
+                                    ropt-33805)))
+                          tmp-33928)
+                        (let ((tmp-33962
+                                ($sc-dispatch args-33803 '((any any) . any))))
+                          (if (if tmp-33962
                                 (@apply
-                                  (lambda (a-33743 init-33744 b-33745)
-                                    (if (symbol? a-33743)
+                                  (lambda (a-33966 init-33967 b-33968)
+                                    (if (symbol? a-33966)
                                       #t
-                                      (if (if (vector? a-33743)
-                                            (if (= (vector-length a-33743) 4)
-                                              (eq? (vector-ref a-33743 0)
+                                      (if (if (vector? a-33966)
+                                            (if (= (vector-length a-33966) 4)
+                                              (eq? (vector-ref a-33966 0)
                                                    'syntax-object)
                                               #f)
                                             #f)
-                                        (symbol? (vector-ref a-33743 1))
+                                        (symbol? (vector-ref a-33966 1))
                                         #f)))
-                                  tmp-33739)
+                                  tmp-33962)
                                 #f)
                             (@apply
-                              (lambda (a-33772 init-33773 b-33774)
-                                (opt-33337
-                                  b-33774
-                                  req-33581
-                                  (cons (list a-33772 init-33773) ropt-33582)))
-                              tmp-33739)
-                            (let ((tmp-33775
-                                    ($sc-dispatch args-33580 '(any . any))))
-                              (if (if tmp-33775
+                              (lambda (a-33995 init-33996 b-33997)
+                                (opt-33560
+                                  b-33997
+                                  req-33804
+                                  (cons (list a-33995 init-33996) ropt-33805)))
+                              tmp-33962)
+                            (let ((tmp-33998
+                                    ($sc-dispatch args-33803 '(any . any))))
+                              (if (if tmp-33998
                                     (@apply
-                                      (lambda (a-33779 b-33780)
-                                        (eq? (syntax->datum a-33779) #:key))
-                                      tmp-33775)
+                                      (lambda (a-34002 b-34003)
+                                        (eq? (syntax->datum a-34002) #:key))
+                                      tmp-33998)
                                     #f)
                                 (@apply
-                                  (lambda (a-33781 b-33782)
-                                    (key-33338
-                                      b-33782
-                                      req-33581
-                                      (reverse ropt-33582)
+                                  (lambda (a-34004 b-34005)
+                                    (key-33561
+                                      b-34005
+                                      req-33804
+                                      (reverse ropt-33805)
                                       '()))
-                                  tmp-33775)
-                                (let ((tmp-33785
-                                        ($sc-dispatch args-33580 '(any any))))
-                                  (if (if tmp-33785
+                                  tmp-33998)
+                                (let ((tmp-34008
+                                        ($sc-dispatch args-33803 '(any any))))
+                                  (if (if tmp-34008
                                         (@apply
-                                          (lambda (a-33789 b-33790)
-                                            (eq? (syntax->datum a-33789)
+                                          (lambda (a-34012 b-34013)
+                                            (eq? (syntax->datum a-34012)
                                                  #:rest))
-                                          tmp-33785)
+                                          tmp-34008)
                                         #f)
                                     (@apply
-                                      (lambda (a-33791 b-33792)
-                                        (rest-33339
-                                          b-33792
-                                          req-33581
-                                          (reverse ropt-33582)
+                                      (lambda (a-34014 b-34015)
+                                        (rest-33562
+                                          b-34015
+                                          req-33804
+                                          (reverse ropt-33805)
                                           '()))
-                                      tmp-33785)
-                                    (let ((tmp-33795 (list args-33580)))
+                                      tmp-34008)
+                                    (let ((tmp-34018 (list args-33803)))
                                       (if (@apply
-                                            (lambda (r-33797)
-                                              (if (symbol? r-33797)
+                                            (lambda (r-34020)
+                                              (if (symbol? r-34020)
                                                 #t
-                                                (if (if (vector? r-33797)
+                                                (if (if (vector? r-34020)
                                                       (if (= (vector-length
-                                                               r-33797)
+                                                               r-34020)
                                                              4)
                                                         (eq? (vector-ref
-                                                               r-33797
+                                                               r-34020
                                                                0)
                                                              'syntax-object)
                                                         #f)
                                                       #f)
                                                   (symbol?
-                                                    (vector-ref r-33797 1))
+                                                    (vector-ref r-34020 1))
                                                   #f)))
-                                            tmp-33795)
+                                            tmp-34018)
                                         (@apply
-                                          (lambda (r-33827)
-                                            (rest-33339
-                                              r-33827
-                                              req-33581
-                                              (reverse ropt-33582)
+                                          (lambda (r-34050)
+                                            (rest-33562
+                                              r-34050
+                                              req-33804
+                                              (reverse ropt-33805)
                                               '()))
-                                          tmp-33795)
+                                          tmp-34018)
                                         (syntax-violation
                                           'lambda*
                                           "invalid optional argument list"
-                                          orig-args-33335
-                                          args-33580)))))))))))))))
-            (key-33338
-              (lambda (args-33846 req-33847 opt-33848 rkey-33849)
-                (let ((tmp-33851 ($sc-dispatch args-33846 '())))
-                  (if tmp-33851
+                                          orig-args-33558
+                                          args-33803)))))))))))))))
+            (key-33561
+              (lambda (args-34069 req-34070 opt-34071 rkey-34072)
+                (let ((tmp-34074 ($sc-dispatch args-34069 '())))
+                  (if tmp-34074
                     (@apply
                       (lambda ()
-                        (check-33340
-                          req-33847
-                          opt-33848
+                        (check-33563
+                          req-34070
+                          opt-34071
                           #f
-                          (cons #f (reverse rkey-33849))))
-                      tmp-33851)
-                    (let ((tmp-33973
-                            ($sc-dispatch args-33846 '(any . any))))
-                      (if (if tmp-33973
+                          (cons #f (reverse rkey-34072))))
+                      tmp-34074)
+                    (let ((tmp-34196
+                            ($sc-dispatch args-34069 '(any . any))))
+                      (if (if tmp-34196
                             (@apply
-                              (lambda (a-33977 b-33978)
-                                (if (symbol? a-33977)
+                              (lambda (a-34200 b-34201)
+                                (if (symbol? a-34200)
                                   #t
-                                  (if (if (vector? a-33977)
-                                        (if (= (vector-length a-33977) 4)
-                                          (eq? (vector-ref a-33977 0)
+                                  (if (if (vector? a-34200)
+                                        (if (= (vector-length a-34200) 4)
+                                          (eq? (vector-ref a-34200 0)
                                                'syntax-object)
                                           #f)
                                         #f)
-                                    (symbol? (vector-ref a-33977 1))
+                                    (symbol? (vector-ref a-34200 1))
                                     #f)))
-                              tmp-33973)
+                              tmp-34196)
                             #f)
                         (@apply
-                          (lambda (a-34005 b-34006)
-                            (let ((tmp-34007
-                                    (symbol->keyword (syntax->datum a-34005))))
-                              (key-33338
-                                b-34006
-                                req-33847
-                                opt-33848
-                                (cons (cons tmp-34007
-                                            (cons a-34005
+                          (lambda (a-34228 b-34229)
+                            (let ((tmp-34230
+                                    (symbol->keyword (syntax->datum a-34228))))
+                              (key-33561
+                                b-34229
+                                req-34070
+                                opt-34071
+                                (cons (cons tmp-34230
+                                            (cons a-34228
                                                   '(#(syntax-object
                                                       #f
                                                       ((top)
@@ -7898,12 +7915,12 @@
                                                        #(ribcage
                                                          #(k)
                                                          #((top))
-                                                         #("l-*-2618"))
+                                                         #("l-*-2524"))
                                                        #(ribcage
                                                          #(a b)
                                                          #((top) (top))
-                                                         #("l-*-2612"
-                                                           "l-*-2613"))
+                                                         #("l-*-2518"
+                                                           "l-*-2519"))
                                                        #(ribcage () () ())
                                                        #(ribcage
                                                          #(args req opt rkey)
@@ -7911,10 +7928,10 @@
                                                            (top)
                                                            (top)
                                                            (top))
-                                                         #("l-*-2601"
-                                                           "l-*-2602"
-                                                           "l-*-2603"
-                                                           "l-*-2604"))
+                                                         #("l-*-2507"
+                                                           "l-*-2508"
+                                                           "l-*-2509"
+                                                           "l-*-2510"))
                                                        #(ribcage
                                                          (check rest
                                                                 key
@@ -7925,15 +7942,15 @@
                                                           (top)
                                                           (top)
                                                           (top))
-                                                         ("l-*-2491"
-                                                          "l-*-2489"
-                                                          "l-*-2487"
-                                                          "l-*-2485"
-                                                          "l-*-2483"))
+                                                         ("l-*-2397"
+                                                          "l-*-2395"
+                                                          "l-*-2393"
+                                                          "l-*-2391"
+                                                          "l-*-2389"))
                                                        #(ribcage
                                                          #(orig-args)
                                                          #((top))
-                                                         #("l-*-2482"))
+                                                         #("l-*-2388"))
                                                        #(ribcage
                                                          (lambda-var-list
                                                            gen-var
@@ -8368,947 +8385,947 @@
                                                           "l-*-45"))
                                                        #(ribcage () () ()))
                                                       (hygiene guile)))))
-                                      rkey-33849))))
-                          tmp-33973)
-                        (let ((tmp-34010
-                                ($sc-dispatch args-33846 '((any any) . any))))
-                          (if (if tmp-34010
+                                      rkey-34072))))
+                          tmp-34196)
+                        (let ((tmp-34233
+                                ($sc-dispatch args-34069 '((any any) . any))))
+                          (if (if tmp-34233
                                 (@apply
-                                  (lambda (a-34014 init-34015 b-34016)
-                                    (if (symbol? a-34014)
+                                  (lambda (a-34237 init-34238 b-34239)
+                                    (if (symbol? a-34237)
                                       #t
-                                      (if (if (vector? a-34014)
-                                            (if (= (vector-length a-34014) 4)
-                                              (eq? (vector-ref a-34014 0)
+                                      (if (if (vector? a-34237)
+                                            (if (= (vector-length a-34237) 4)
+                                              (eq? (vector-ref a-34237 0)
                                                    'syntax-object)
                                               #f)
                                             #f)
-                                        (symbol? (vector-ref a-34014 1))
+                                        (symbol? (vector-ref a-34237 1))
                                         #f)))
-                                  tmp-34010)
+                                  tmp-34233)
                                 #f)
                             (@apply
-                              (lambda (a-34043 init-34044 b-34045)
-                                (let ((tmp-34046
+                              (lambda (a-34266 init-34267 b-34268)
+                                (let ((tmp-34269
                                         (symbol->keyword
-                                          (syntax->datum a-34043))))
-                                  (key-33338
-                                    b-34045
-                                    req-33847
-                                    opt-33848
-                                    (cons (list tmp-34046 a-34043 init-34044)
-                                          rkey-33849))))
-                              tmp-34010)
-                            (let ((tmp-34049
+                                          (syntax->datum a-34266))))
+                                  (key-33561
+                                    b-34268
+                                    req-34070
+                                    opt-34071
+                                    (cons (list tmp-34269 a-34266 init-34267)
+                                          rkey-34072))))
+                              tmp-34233)
+                            (let ((tmp-34272
                                     ($sc-dispatch
-                                      args-33846
+                                      args-34069
                                       '((any any any) . any))))
-                              (if (if tmp-34049
+                              (if (if tmp-34272
                                     (@apply
-                                      (lambda (a-34053
-                                               init-34054
-                                               k-34055
-                                               b-34056)
-                                        (if (if (symbol? a-34053)
+                                      (lambda (a-34276
+                                               init-34277
+                                               k-34278
+                                               b-34279)
+                                        (if (if (symbol? a-34276)
                                               #t
-                                              (if (if (vector? a-34053)
+                                              (if (if (vector? a-34276)
                                                     (if (= (vector-length
-                                                             a-34053)
+                                                             a-34276)
                                                            4)
                                                       (eq? (vector-ref
-                                                             a-34053
+                                                             a-34276
                                                              0)
                                                            'syntax-object)
                                                       #f)
                                                     #f)
                                                 (symbol?
-                                                  (vector-ref a-34053 1))
+                                                  (vector-ref a-34276 1))
                                                 #f))
-                                          (keyword? (syntax->datum k-34055))
+                                          (keyword? (syntax->datum k-34278))
                                           #f))
-                                      tmp-34049)
+                                      tmp-34272)
                                     #f)
                                 (@apply
-                                  (lambda (a-34083 init-34084 k-34085 b-34086)
-                                    (key-33338
-                                      b-34086
-                                      req-33847
-                                      opt-33848
-                                      (cons (list k-34085 a-34083 init-34084)
-                                            rkey-33849)))
-                                  tmp-34049)
-                                (let ((tmp-34087
-                                        ($sc-dispatch args-33846 '(any))))
-                                  (if (if tmp-34087
+                                  (lambda (a-34306 init-34307 k-34308 b-34309)
+                                    (key-33561
+                                      b-34309
+                                      req-34070
+                                      opt-34071
+                                      (cons (list k-34308 a-34306 init-34307)
+                                            rkey-34072)))
+                                  tmp-34272)
+                                (let ((tmp-34310
+                                        ($sc-dispatch args-34069 '(any))))
+                                  (if (if tmp-34310
                                         (@apply
-                                          (lambda (aok-34091)
-                                            (eq? (syntax->datum aok-34091)
+                                          (lambda (aok-34314)
+                                            (eq? (syntax->datum aok-34314)
                                                  #:allow-other-keys))
-                                          tmp-34087)
+                                          tmp-34310)
                                         #f)
                                     (@apply
-                                      (lambda (aok-34092)
-                                        (check-33340
-                                          req-33847
-                                          opt-33848
+                                      (lambda (aok-34315)
+                                        (check-33563
+                                          req-34070
+                                          opt-34071
                                           #f
-                                          (cons #t (reverse rkey-33849))))
-                                      tmp-34087)
-                                    (let ((tmp-34211
+                                          (cons #t (reverse rkey-34072))))
+                                      tmp-34310)
+                                    (let ((tmp-34434
                                             ($sc-dispatch
-                                              args-33846
+                                              args-34069
                                               '(any any any))))
-                                      (if (if tmp-34211
+                                      (if (if tmp-34434
                                             (@apply
-                                              (lambda (aok-34215
-                                                       a-34216
-                                                       b-34217)
+                                              (lambda (aok-34438
+                                                       a-34439
+                                                       b-34440)
                                                 (if (eq? (syntax->datum
-                                                           aok-34215)
+                                                           aok-34438)
                                                          #:allow-other-keys)
-                                                  (eq? (syntax->datum a-34216)
+                                                  (eq? (syntax->datum a-34439)
                                                        #:rest)
                                                   #f))
-                                              tmp-34211)
+                                              tmp-34434)
                                             #f)
                                         (@apply
-                                          (lambda (aok-34218 a-34219 b-34220)
-                                            (rest-33339
-                                              b-34220
-                                              req-33847
-                                              opt-33848
-                                              (cons #t (reverse rkey-33849))))
-                                          tmp-34211)
-                                        (let ((tmp-34223
+                                          (lambda (aok-34441 a-34442 b-34443)
+                                            (rest-33562
+                                              b-34443
+                                              req-34070
+                                              opt-34071
+                                              (cons #t (reverse rkey-34072))))
+                                          tmp-34434)
+                                        (let ((tmp-34446
                                                 ($sc-dispatch
-                                                  args-33846
+                                                  args-34069
                                                   '(any . any))))
-                                          (if (if tmp-34223
+                                          (if (if tmp-34446
                                                 (@apply
-                                                  (lambda (aok-34227 r-34228)
+                                                  (lambda (aok-34450 r-34451)
                                                     (if (eq? (syntax->datum
-                                                               aok-34227)
+                                                               aok-34450)
                                                              
#:allow-other-keys)
-                                                      (if (symbol? r-34228)
+                                                      (if (symbol? r-34451)
                                                         #t
                                                         (if (if (vector?
-                                                                  r-34228)
+                                                                  r-34451)
                                                               (if (= 
(vector-length
-                                                                       r-34228)
+                                                                       r-34451)
                                                                      4)
                                                                 (eq? 
(vector-ref
-                                                                       r-34228
+                                                                       r-34451
                                                                        0)
                                                                      
'syntax-object)
                                                                 #f)
                                                               #f)
                                                           (symbol?
                                                             (vector-ref
-                                                              r-34228
+                                                              r-34451
                                                               1))
                                                           #f))
                                                       #f))
-                                                  tmp-34223)
+                                                  tmp-34446)
                                                 #f)
                                             (@apply
-                                              (lambda (aok-34255 r-34256)
-                                                (rest-33339
-                                                  r-34256
-                                                  req-33847
-                                                  opt-33848
+                                              (lambda (aok-34478 r-34479)
+                                                (rest-33562
+                                                  r-34479
+                                                  req-34070
+                                                  opt-34071
                                                   (cons #t
-                                                        (reverse rkey-33849))))
-                                              tmp-34223)
-                                            (let ((tmp-34259
+                                                        (reverse rkey-34072))))
+                                              tmp-34446)
+                                            (let ((tmp-34482
                                                     ($sc-dispatch
-                                                      args-33846
+                                                      args-34069
                                                       '(any any))))
-                                              (if (if tmp-34259
+                                              (if (if tmp-34482
                                                     (@apply
-                                                      (lambda (a-34263 b-34264)
+                                                      (lambda (a-34486 b-34487)
                                                         (eq? (syntax->datum
-                                                               a-34263)
+                                                               a-34486)
                                                              #:rest))
-                                                      tmp-34259)
+                                                      tmp-34482)
                                                     #f)
                                                 (@apply
-                                                  (lambda (a-34265 b-34266)
-                                                    (rest-33339
-                                                      b-34266
-                                                      req-33847
-                                                      opt-33848
+                                                  (lambda (a-34488 b-34489)
+                                                    (rest-33562
+                                                      b-34489
+                                                      req-34070
+                                                      opt-34071
                                                       (cons #f
                                                             (reverse
-                                                              rkey-33849))))
-                                                  tmp-34259)
-                                                (let ((tmp-34269
-                                                        (list args-33846)))
+                                                              rkey-34072))))
+                                                  tmp-34482)
+                                                (let ((tmp-34492
+                                                        (list args-34069)))
                                                   (if (@apply
-                                                        (lambda (r-34271)
-                                                          (if (symbol? r-34271)
+                                                        (lambda (r-34494)
+                                                          (if (symbol? r-34494)
                                                             #t
                                                             (if (if (vector?
-                                                                      r-34271)
+                                                                      r-34494)
                                                                   (if (= 
(vector-length
-                                                                           
r-34271)
+                                                                           
r-34494)
                                                                          4)
                                                                     (eq? 
(vector-ref
-                                                                           
r-34271
+                                                                           
r-34494
                                                                            0)
                                                                          
'syntax-object)
                                                                     #f)
                                                                   #f)
                                                               (symbol?
                                                                 (vector-ref
-                                                                  r-34271
+                                                                  r-34494
                                                                   1))
                                                               #f)))
-                                                        tmp-34269)
+                                                        tmp-34492)
                                                     (@apply
-                                                      (lambda (r-34301)
-                                                        (rest-33339
-                                                          r-34301
-                                                          req-33847
-                                                          opt-33848
+                                                      (lambda (r-34524)
+                                                        (rest-33562
+                                                          r-34524
+                                                          req-34070
+                                                          opt-34071
                                                           (cons #f
                                                                 (reverse
-                                                                  
rkey-33849))))
-                                                      tmp-34269)
+                                                                  
rkey-34072))))
+                                                      tmp-34492)
                                                     (syntax-violation
                                                       'lambda*
                                                       "invalid keyword 
argument list"
-                                                      orig-args-33335
-                                                      
args-33846)))))))))))))))))))))
-            (rest-33339
-              (lambda (args-34329 req-34330 opt-34331 kw-34332)
-                (let ((tmp-34334 (list args-34329)))
+                                                      orig-args-33558
+                                                      
args-34069)))))))))))))))))))))
+            (rest-33562
+              (lambda (args-34552 req-34553 opt-34554 kw-34555)
+                (let ((tmp-34557 (list args-34552)))
                   (if (@apply
-                        (lambda (r-34336)
-                          (if (symbol? r-34336)
+                        (lambda (r-34559)
+                          (if (symbol? r-34559)
                             #t
-                            (if (if (vector? r-34336)
-                                  (if (= (vector-length r-34336) 4)
-                                    (eq? (vector-ref r-34336 0) 'syntax-object)
+                            (if (if (vector? r-34559)
+                                  (if (= (vector-length r-34559) 4)
+                                    (eq? (vector-ref r-34559 0) 'syntax-object)
                                     #f)
                                   #f)
-                              (symbol? (vector-ref r-34336 1))
+                              (symbol? (vector-ref r-34559 1))
                               #f)))
-                        tmp-34334)
+                        tmp-34557)
                     (@apply
-                      (lambda (r-34366)
-                        (check-33340
-                          req-34330
-                          opt-34331
-                          r-34366
-                          kw-34332))
-                      tmp-34334)
+                      (lambda (r-34589)
+                        (check-33563
+                          req-34553
+                          opt-34554
+                          r-34589
+                          kw-34555))
+                      tmp-34557)
                     (syntax-violation
                       'lambda*
                       "invalid rest argument"
-                      orig-args-33335
-                      args-34329)))))
-            (check-33340
-              (lambda (req-34494 opt-34495 rest-34496 kw-34497)
-                (if (distinct-bound-ids?-4577
+                      orig-args-33558
+                      args-34552)))))
+            (check-33563
+              (lambda (req-34717 opt-34718 rest-34719 kw-34720)
+                (if (distinct-bound-ids?-4373
                       (append
-                        req-34494
-                        (map car opt-34495)
-                        (if rest-34496 (list rest-34496) '())
-                        (if (pair? kw-34497)
-                          (map cadr (cdr kw-34497))
+                        req-34717
+                        (map car opt-34718)
+                        (if rest-34719 (list rest-34719) '())
+                        (if (pair? kw-34720)
+                          (map cadr (cdr kw-34720))
                           '())))
-                  (values req-34494 opt-34495 rest-34496 kw-34497)
+                  (values req-34717 opt-34718 rest-34719 kw-34720)
                   (syntax-violation
                     'lambda*
                     "duplicate identifier in argument list"
-                    orig-args-33335)))))
-           (req-33336 orig-args-33335 '()))))
-     (expand-lambda-case-4598
-       (lambda (e-34606
-                r-34607
-                w-34608
-                s-34609
-                mod-34610
-                get-formals-34611
-                clauses-34612)
+                    orig-args-33558)))))
+           (req-33559 orig-args-33558 '()))))
+     (expand-lambda-case-4394
+       (lambda (e-34829
+                r-34830
+                w-34831
+                s-34832
+                mod-34833
+                get-formals-34834
+                clauses-34835)
          (letrec*
-           ((parse-req-34613
-              (lambda (req-34746
-                       opt-34747
-                       rest-34748
-                       kw-34749
-                       body-34750)
-                (let ((vars-34751 (map gen-var-4600 req-34746))
-                      (labels-34752 (gen-labels-4553 req-34746)))
-                  (let ((r*-34753
-                          (extend-var-env-4546
-                            labels-34752
-                            vars-34751
-                            r-34607))
-                        (w*-34754
-                          (make-binding-wrap-4564
-                            req-34746
-                            labels-34752
-                            w-34608)))
-                    (parse-opt-34614
-                      (map syntax->datum req-34746)
-                      opt-34747
-                      rest-34748
-                      kw-34749
-                      body-34750
-                      (reverse vars-34751)
-                      r*-34753
-                      w*-34754
+           ((parse-req-34836
+              (lambda (req-34969
+                       opt-34970
+                       rest-34971
+                       kw-34972
+                       body-34973)
+                (let ((vars-34974 (map gen-var-4396 req-34969))
+                      (labels-34975 (gen-labels-4349 req-34969)))
+                  (let ((r*-34976
+                          (extend-var-env-4342
+                            labels-34975
+                            vars-34974
+                            r-34830))
+                        (w*-34977
+                          (make-binding-wrap-4360
+                            req-34969
+                            labels-34975
+                            w-34831)))
+                    (parse-opt-34837
+                      (map syntax->datum req-34969)
+                      opt-34970
+                      rest-34971
+                      kw-34972
+                      body-34973
+                      (reverse vars-34974)
+                      r*-34976
+                      w*-34977
                       '()
                       '())))))
-            (parse-opt-34614
-              (lambda (req-34951
-                       opt-34952
-                       rest-34953
-                       kw-34954
-                       body-34955
-                       vars-34956
-                       r*-34957
-                       w*-34958
-                       out-34959
-                       inits-34960)
-                (if (pair? opt-34952)
-                  (let ((tmp-34961 (car opt-34952)))
-                    (let ((tmp-34962 ($sc-dispatch tmp-34961 '(any any))))
-                      (if tmp-34962
+            (parse-opt-34837
+              (lambda (req-35174
+                       opt-35175
+                       rest-35176
+                       kw-35177
+                       body-35178
+                       vars-35179
+                       r*-35180
+                       w*-35181
+                       out-35182
+                       inits-35183)
+                (if (pair? opt-35175)
+                  (let ((tmp-35184 (car opt-35175)))
+                    (let ((tmp-35185 ($sc-dispatch tmp-35184 '(any any))))
+                      (if tmp-35185
                         (@apply
-                          (lambda (id-34964 i-34965)
-                            (let ((v-34966
-                                    (let ((id-34974
-                                            (if (if (vector? id-34964)
+                          (lambda (id-35187 i-35188)
+                            (let ((v-35189
+                                    (let ((id-35197
+                                            (if (if (vector? id-35187)
                                                   (if (= (vector-length
-                                                           id-34964)
+                                                           id-35187)
                                                          4)
                                                     (eq? (vector-ref
-                                                           id-34964
+                                                           id-35187
                                                            0)
                                                          'syntax-object)
                                                     #f)
                                                   #f)
-                                              (vector-ref id-34964 1)
-                                              id-34964)))
+                                              (vector-ref id-35187 1)
+                                              id-35187)))
                                       (gensym
                                         (string-append
-                                          (symbol->string id-34974)
+                                          (symbol->string id-35197)
                                           "-")))))
-                              (let ((l-34967 (gen-labels-4553 (list v-34966))))
-                                (let ((r**-34968
-                                        (extend-var-env-4546
-                                          l-34967
-                                          (list v-34966)
-                                          r*-34957)))
-                                  (let ((w**-34969
-                                          (make-binding-wrap-4564
-                                            (list id-34964)
-                                            l-34967
-                                            w*-34958)))
-                                    (parse-opt-34614
-                                      req-34951
-                                      (cdr opt-34952)
-                                      rest-34953
-                                      kw-34954
-                                      body-34955
-                                      (cons v-34966 vars-34956)
-                                      r**-34968
-                                      w**-34969
-                                      (cons (syntax->datum id-34964) out-34959)
-                                      (cons (expand-4586
-                                              i-34965
-                                              r*-34957
-                                              w*-34958
-                                              mod-34610)
-                                            inits-34960)))))))
-                          tmp-34962)
+                              (let ((l-35190 (gen-labels-4349 (list v-35189))))
+                                (let ((r**-35191
+                                        (extend-var-env-4342
+                                          l-35190
+                                          (list v-35189)
+                                          r*-35180)))
+                                  (let ((w**-35192
+                                          (make-binding-wrap-4360
+                                            (list id-35187)
+                                            l-35190
+                                            w*-35181)))
+                                    (parse-opt-34837
+                                      req-35174
+                                      (cdr opt-35175)
+                                      rest-35176
+                                      kw-35177
+                                      body-35178
+                                      (cons v-35189 vars-35179)
+                                      r**-35191
+                                      w**-35192
+                                      (cons (syntax->datum id-35187) out-35182)
+                                      (cons (expand-4382
+                                              i-35188
+                                              r*-35180
+                                              w*-35181
+                                              mod-34833)
+                                            inits-35183)))))))
+                          tmp-35185)
                         (syntax-violation
                           #f
                           "source expression failed to match any pattern"
-                          tmp-34961))))
-                  (if rest-34953
-                    (let ((v-35232
-                            (let ((id-35242
-                                    (if (if (vector? rest-34953)
-                                          (if (= (vector-length rest-34953) 4)
-                                            (eq? (vector-ref rest-34953 0)
+                          tmp-35184))))
+                  (if rest-35176
+                    (let ((v-35455
+                            (let ((id-35465
+                                    (if (if (vector? rest-35176)
+                                          (if (= (vector-length rest-35176) 4)
+                                            (eq? (vector-ref rest-35176 0)
                                                  'syntax-object)
                                             #f)
                                           #f)
-                                      (vector-ref rest-34953 1)
-                                      rest-34953)))
+                                      (vector-ref rest-35176 1)
+                                      rest-35176)))
                               (gensym
                                 (string-append
-                                  (symbol->string id-35242)
+                                  (symbol->string id-35465)
                                   "-")))))
-                      (let ((l-35233 (gen-labels-4553 (list v-35232))))
-                        (let ((r*-35234
-                                (extend-var-env-4546
-                                  l-35233
-                                  (list v-35232)
-                                  r*-34957)))
-                          (let ((w*-35235
-                                  (make-binding-wrap-4564
-                                    (list rest-34953)
-                                    l-35233
-                                    w*-34958)))
-                            (parse-kw-34615
-                              req-34951
-                              (if (pair? out-34959) (reverse out-34959) #f)
-                              (syntax->datum rest-34953)
-                              (if (pair? kw-34954) (cdr kw-34954) kw-34954)
-                              body-34955
-                              (cons v-35232 vars-34956)
-                              r*-35234
-                              w*-35235
-                              (if (pair? kw-34954) (car kw-34954) #f)
+                      (let ((l-35456 (gen-labels-4349 (list v-35455))))
+                        (let ((r*-35457
+                                (extend-var-env-4342
+                                  l-35456
+                                  (list v-35455)
+                                  r*-35180)))
+                          (let ((w*-35458
+                                  (make-binding-wrap-4360
+                                    (list rest-35176)
+                                    l-35456
+                                    w*-35181)))
+                            (parse-kw-34838
+                              req-35174
+                              (if (pair? out-35182) (reverse out-35182) #f)
+                              (syntax->datum rest-35176)
+                              (if (pair? kw-35177) (cdr kw-35177) kw-35177)
+                              body-35178
+                              (cons v-35455 vars-35179)
+                              r*-35457
+                              w*-35458
+                              (if (pair? kw-35177) (car kw-35177) #f)
                               '()
-                              inits-34960)))))
-                    (parse-kw-34615
-                      req-34951
-                      (if (pair? out-34959) (reverse out-34959) #f)
+                              inits-35183)))))
+                    (parse-kw-34838
+                      req-35174
+                      (if (pair? out-35182) (reverse out-35182) #f)
                       #f
-                      (if (pair? kw-34954) (cdr kw-34954) kw-34954)
-                      body-34955
-                      vars-34956
-                      r*-34957
-                      w*-34958
-                      (if (pair? kw-34954) (car kw-34954) #f)
+                      (if (pair? kw-35177) (cdr kw-35177) kw-35177)
+                      body-35178
+                      vars-35179
+                      r*-35180
+                      w*-35181
+                      (if (pair? kw-35177) (car kw-35177) #f)
                       '()
-                      inits-34960)))))
-            (parse-kw-34615
-              (lambda (req-35425
-                       opt-35426
-                       rest-35427
-                       kw-35428
-                       body-35429
-                       vars-35430
-                       r*-35431
-                       w*-35432
-                       aok-35433
-                       out-35434
-                       inits-35435)
-                (if (pair? kw-35428)
-                  (let ((tmp-35436 (car kw-35428)))
-                    (let ((tmp-35437
-                            ($sc-dispatch tmp-35436 '(any any any))))
-                      (if tmp-35437
+                      inits-35183)))))
+            (parse-kw-34838
+              (lambda (req-35648
+                       opt-35649
+                       rest-35650
+                       kw-35651
+                       body-35652
+                       vars-35653
+                       r*-35654
+                       w*-35655
+                       aok-35656
+                       out-35657
+                       inits-35658)
+                (if (pair? kw-35651)
+                  (let ((tmp-35659 (car kw-35651)))
+                    (let ((tmp-35660
+                            ($sc-dispatch tmp-35659 '(any any any))))
+                      (if tmp-35660
                         (@apply
-                          (lambda (k-35439 id-35440 i-35441)
-                            (let ((v-35442
-                                    (let ((id-35450
-                                            (if (if (vector? id-35440)
+                          (lambda (k-35662 id-35663 i-35664)
+                            (let ((v-35665
+                                    (let ((id-35673
+                                            (if (if (vector? id-35663)
                                                   (if (= (vector-length
-                                                           id-35440)
+                                                           id-35663)
                                                          4)
                                                     (eq? (vector-ref
-                                                           id-35440
+                                                           id-35663
                                                            0)
                                                          'syntax-object)
                                                     #f)
                                                   #f)
-                                              (vector-ref id-35440 1)
-                                              id-35440)))
+                                              (vector-ref id-35663 1)
+                                              id-35663)))
                                       (gensym
                                         (string-append
-                                          (symbol->string id-35450)
+                                          (symbol->string id-35673)
                                           "-")))))
-                              (let ((l-35443 (gen-labels-4553 (list v-35442))))
-                                (let ((r**-35444
-                                        (extend-var-env-4546
-                                          l-35443
-                                          (list v-35442)
-                                          r*-35431)))
-                                  (let ((w**-35445
-                                          (make-binding-wrap-4564
-                                            (list id-35440)
-                                            l-35443
-                                            w*-35432)))
-                                    (parse-kw-34615
-                                      req-35425
-                                      opt-35426
-                                      rest-35427
-                                      (cdr kw-35428)
-                                      body-35429
-                                      (cons v-35442 vars-35430)
-                                      r**-35444
-                                      w**-35445
-                                      aok-35433
-                                      (cons (list (syntax->datum k-35439)
-                                                  (syntax->datum id-35440)
-                                                  v-35442)
-                                            out-35434)
-                                      (cons (expand-4586
-                                              i-35441
-                                              r*-35431
-                                              w*-35432
-                                              mod-34610)
-                                            inits-35435)))))))
-                          tmp-35437)
+                              (let ((l-35666 (gen-labels-4349 (list v-35665))))
+                                (let ((r**-35667
+                                        (extend-var-env-4342
+                                          l-35666
+                                          (list v-35665)
+                                          r*-35654)))
+                                  (let ((w**-35668
+                                          (make-binding-wrap-4360
+                                            (list id-35663)
+                                            l-35666
+                                            w*-35655)))
+                                    (parse-kw-34838
+                                      req-35648
+                                      opt-35649
+                                      rest-35650
+                                      (cdr kw-35651)
+                                      body-35652
+                                      (cons v-35665 vars-35653)
+                                      r**-35667
+                                      w**-35668
+                                      aok-35656
+                                      (cons (list (syntax->datum k-35662)
+                                                  (syntax->datum id-35663)
+                                                  v-35665)
+                                            out-35657)
+                                      (cons (expand-4382
+                                              i-35664
+                                              r*-35654
+                                              w*-35655
+                                              mod-34833)
+                                            inits-35658)))))))
+                          tmp-35660)
                         (syntax-violation
                           #f
                           "source expression failed to match any pattern"
-                          tmp-35436))))
-                  (parse-body-34616
-                    req-35425
-                    opt-35426
-                    rest-35427
-                    (if (if aok-35433 aok-35433 (pair? out-35434))
-                      (cons aok-35433 (reverse out-35434))
+                          tmp-35659))))
+                  (parse-body-34839
+                    req-35648
+                    opt-35649
+                    rest-35650
+                    (if (if aok-35656 aok-35656 (pair? out-35657))
+                      (cons aok-35656 (reverse out-35657))
                       #f)
-                    body-35429
-                    (reverse vars-35430)
-                    r*-35431
-                    w*-35432
-                    (reverse inits-35435)
+                    body-35652
+                    (reverse vars-35653)
+                    r*-35654
+                    w*-35655
+                    (reverse inits-35658)
                     '()))))
-            (parse-body-34616
-              (lambda (req-35717
-                       opt-35718
-                       rest-35719
-                       kw-35720
-                       body-35721
-                       vars-35722
-                       r*-35723
-                       w*-35724
-                       inits-35725
-                       meta-35726)
-                (let ((tmp-35728
-                        ($sc-dispatch body-35721 '(any any . each-any))))
-                  (if (if tmp-35728
+            (parse-body-34839
+              (lambda (req-35940
+                       opt-35941
+                       rest-35942
+                       kw-35943
+                       body-35944
+                       vars-35945
+                       r*-35946
+                       w*-35947
+                       inits-35948
+                       meta-35949)
+                (let ((tmp-35951
+                        ($sc-dispatch body-35944 '(any any . each-any))))
+                  (if (if tmp-35951
                         (@apply
-                          (lambda (docstring-35732 e1-35733 e2-35734)
-                            (string? (syntax->datum docstring-35732)))
-                          tmp-35728)
+                          (lambda (docstring-35955 e1-35956 e2-35957)
+                            (string? (syntax->datum docstring-35955)))
+                          tmp-35951)
                         #f)
                     (@apply
-                      (lambda (docstring-35735 e1-35736 e2-35737)
-                        (parse-body-34616
-                          req-35717
-                          opt-35718
-                          rest-35719
-                          kw-35720
-                          (cons e1-35736 e2-35737)
-                          vars-35722
-                          r*-35723
-                          w*-35724
-                          inits-35725
+                      (lambda (docstring-35958 e1-35959 e2-35960)
+                        (parse-body-34839
+                          req-35940
+                          opt-35941
+                          rest-35942
+                          kw-35943
+                          (cons e1-35959 e2-35960)
+                          vars-35945
+                          r*-35946
+                          w*-35947
+                          inits-35948
                           (append
-                            meta-35726
+                            meta-35949
                             (list (cons 'documentation
-                                        (syntax->datum docstring-35735))))))
-                      tmp-35728)
-                    (let ((tmp-35738
+                                        (syntax->datum docstring-35958))))))
+                      tmp-35951)
+                    (let ((tmp-35961
                             ($sc-dispatch
-                              body-35721
+                              body-35944
                               '(#(vector #(each (any . any)))
                                 any
                                 .
                                 each-any))))
-                      (if tmp-35738
+                      (if tmp-35961
                         (@apply
-                          (lambda (k-35742 v-35743 e1-35744 e2-35745)
-                            (parse-body-34616
-                              req-35717
-                              opt-35718
-                              rest-35719
-                              kw-35720
-                              (cons e1-35744 e2-35745)
-                              vars-35722
-                              r*-35723
-                              w*-35724
-                              inits-35725
+                          (lambda (k-35965 v-35966 e1-35967 e2-35968)
+                            (parse-body-34839
+                              req-35940
+                              opt-35941
+                              rest-35942
+                              kw-35943
+                              (cons e1-35967 e2-35968)
+                              vars-35945
+                              r*-35946
+                              w*-35947
+                              inits-35948
                               (append
-                                meta-35726
-                                (syntax->datum (map cons k-35742 v-35743)))))
-                          tmp-35738)
-                        (let ((tmp-35746
-                                ($sc-dispatch body-35721 '(any . each-any))))
-                          (if tmp-35746
+                                meta-35949
+                                (syntax->datum (map cons k-35965 v-35966)))))
+                          tmp-35961)
+                        (let ((tmp-35969
+                                ($sc-dispatch body-35944 '(any . each-any))))
+                          (if tmp-35969
                             (@apply
-                              (lambda (e1-35750 e2-35751)
+                              (lambda (e1-35973 e2-35974)
                                 (values
-                                  meta-35726
-                                  req-35717
-                                  opt-35718
-                                  rest-35719
-                                  kw-35720
-                                  inits-35725
-                                  vars-35722
-                                  (expand-body-4590
-                                    (cons e1-35750 e2-35751)
-                                    (let ((x-35763
+                                  meta-35949
+                                  req-35940
+                                  opt-35941
+                                  rest-35942
+                                  kw-35943
+                                  inits-35948
+                                  vars-35945
+                                  (expand-body-4386
+                                    (cons e1-35973 e2-35974)
+                                    (let ((x-35986
                                             (begin
-                                              (if (if (pair? e-34606)
-                                                    s-34609
+                                              (if (if (pair? e-34829)
+                                                    s-34832
                                                     #f)
                                                 (set-source-properties!
-                                                  e-34606
-                                                  s-34609))
-                                              e-34606)))
-                                      (if (if (null? (car w-34608))
-                                            (null? (cdr w-34608))
+                                                  e-34829
+                                                  s-34832))
+                                              e-34829)))
+                                      (if (if (null? (car w-34831))
+                                            (null? (cdr w-34831))
                                             #f)
-                                        x-35763
-                                        (if (if (vector? x-35763)
-                                              (if (= (vector-length x-35763) 4)
-                                                (eq? (vector-ref x-35763 0)
+                                        x-35986
+                                        (if (if (vector? x-35986)
+                                              (if (= (vector-length x-35986) 4)
+                                                (eq? (vector-ref x-35986 0)
                                                      'syntax-object)
                                                 #f)
                                               #f)
-                                          (let ((expression-35795
-                                                  (vector-ref x-35763 1))
-                                                (wrap-35796
-                                                  (let ((w2-35804
+                                          (let ((expression-36018
+                                                  (vector-ref x-35986 1))
+                                                (wrap-36019
+                                                  (let ((w2-36027
                                                           (vector-ref
-                                                            x-35763
+                                                            x-35986
                                                             2)))
-                                                    (let ((m1-35805
-                                                            (car w-34608))
-                                                          (s1-35806
-                                                            (cdr w-34608)))
-                                                      (if (null? m1-35805)
-                                                        (if (null? s1-35806)
-                                                          w2-35804
-                                                          (cons (car w2-35804)
-                                                                (let ((m2-35821
-                                                                        (cdr 
w2-35804)))
-                                                                  (if (null? 
m2-35821)
-                                                                    s1-35806
+                                                    (let ((m1-36028
+                                                            (car w-34831))
+                                                          (s1-36029
+                                                            (cdr w-34831)))
+                                                      (if (null? m1-36028)
+                                                        (if (null? s1-36029)
+                                                          w2-36027
+                                                          (cons (car w2-36027)
+                                                                (let ((m2-36044
+                                                                        (cdr 
w2-36027)))
+                                                                  (if (null? 
m2-36044)
+                                                                    s1-36029
                                                                     (append
-                                                                      s1-35806
-                                                                      
m2-35821)))))
-                                                        (cons (let ((m2-35829
-                                                                      (car 
w2-35804)))
-                                                                (if (null? 
m2-35829)
-                                                                  m1-35805
+                                                                      s1-36029
+                                                                      
m2-36044)))))
+                                                        (cons (let ((m2-36052
+                                                                      (car 
w2-36027)))
+                                                                (if (null? 
m2-36052)
+                                                                  m1-36028
                                                                   (append
-                                                                    m1-35805
-                                                                    m2-35829)))
-                                                              (let ((m2-35837
-                                                                      (cdr 
w2-35804)))
-                                                                (if (null? 
m2-35837)
-                                                                  s1-35806
+                                                                    m1-36028
+                                                                    m2-36052)))
+                                                              (let ((m2-36060
+                                                                      (cdr 
w2-36027)))
+                                                                (if (null? 
m2-36060)
+                                                                  s1-36029
                                                                   (append
-                                                                    s1-35806
-                                                                    
m2-35837))))))))
-                                                (module-35797
-                                                  (vector-ref x-35763 3)))
+                                                                    s1-36029
+                                                                    
m2-36060))))))))
+                                                (module-36020
+                                                  (vector-ref x-35986 3)))
                                             (vector
                                               'syntax-object
-                                              expression-35795
-                                              wrap-35796
-                                              module-35797))
-                                          (if (null? x-35763)
-                                            x-35763
+                                              expression-36018
+                                              wrap-36019
+                                              module-36020))
+                                          (if (null? x-35986)
+                                            x-35986
                                             (vector
                                               'syntax-object
-                                              x-35763
-                                              w-34608
-                                              mod-34610)))))
-                                    r*-35723
-                                    w*-35724
-                                    mod-34610)))
-                              tmp-35746)
+                                              x-35986
+                                              w-34831
+                                              mod-34833)))))
+                                    r*-35946
+                                    w*-35947
+                                    mod-34833)))
+                              tmp-35969)
                             (syntax-violation
                               #f
                               "source expression failed to match any pattern"
-                              body-35721))))))))))
-           (let ((tmp-34618 ($sc-dispatch clauses-34612 '())))
-             (if tmp-34618
-               (@apply (lambda () (values '() #f)) tmp-34618)
-               (let ((tmp-34622
+                              body-35944))))))))))
+           (let ((tmp-34841 ($sc-dispatch clauses-34835 '())))
+             (if tmp-34841
+               (@apply (lambda () (values '() #f)) tmp-34841)
+               (let ((tmp-34845
                        ($sc-dispatch
-                         clauses-34612
+                         clauses-34835
                          '((any any . each-any)
                            .
                            #(each (any any . each-any))))))
-                 (if tmp-34622
+                 (if tmp-34845
                    (@apply
-                     (lambda (args-34626
-                              e1-34627
-                              e2-34628
-                              args*-34629
-                              e1*-34630
-                              e2*-34631)
+                     (lambda (args-34849
+                              e1-34850
+                              e2-34851
+                              args*-34852
+                              e1*-34853
+                              e2*-34854)
                        (call-with-values
-                         (lambda () (get-formals-34611 args-34626))
-                         (lambda (req-34632 opt-34633 rest-34634 kw-34635)
+                         (lambda () (get-formals-34834 args-34849))
+                         (lambda (req-34855 opt-34856 rest-34857 kw-34858)
                            (call-with-values
                              (lambda ()
-                               (parse-req-34613
-                                 req-34632
-                                 opt-34633
-                                 rest-34634
-                                 kw-34635
-                                 (cons e1-34627 e2-34628)))
-                             (lambda (meta-34702
-                                      req-34703
-                                      opt-34704
-                                      rest-34705
-                                      kw-34706
-                                      inits-34707
-                                      vars-34708
-                                      body-34709)
+                               (parse-req-34836
+                                 req-34855
+                                 opt-34856
+                                 rest-34857
+                                 kw-34858
+                                 (cons e1-34850 e2-34851)))
+                             (lambda (meta-34925
+                                      req-34926
+                                      opt-34927
+                                      rest-34928
+                                      kw-34929
+                                      inits-34930
+                                      vars-34931
+                                      body-34932)
                                (call-with-values
                                  (lambda ()
-                                   (expand-lambda-case-4598
-                                     e-34606
-                                     r-34607
-                                     w-34608
-                                     s-34609
-                                     mod-34610
-                                     get-formals-34611
-                                     (map (lambda (tmp-2961-34710
-                                                   tmp-2960-34711
-                                                   tmp-2959-34712)
-                                            (cons tmp-2959-34712
-                                                  (cons tmp-2960-34711
-                                                        tmp-2961-34710)))
-                                          e2*-34631
-                                          e1*-34630
-                                          args*-34629)))
-                                 (lambda (meta*-34713 else*-34714)
+                                   (expand-lambda-case-4394
+                                     e-34829
+                                     r-34830
+                                     w-34831
+                                     s-34832
+                                     mod-34833
+                                     get-formals-34834
+                                     (map (lambda (tmp-2859-34933
+                                                   tmp-2858-34934
+                                                   tmp-2857-34935)
+                                            (cons tmp-2857-34935
+                                                  (cons tmp-2858-34934
+                                                        tmp-2859-34933)))
+                                          e2*-34854
+                                          e1*-34853
+                                          args*-34852)))
+                                 (lambda (meta*-34936 else*-34937)
                                    (values
-                                     (append meta-34702 meta*-34713)
+                                     (append meta-34925 meta*-34936)
                                      (make-struct/no-tail
                                        (vector-ref %expanded-vtables 15)
-                                       s-34609
-                                       req-34703
-                                       opt-34704
-                                       rest-34705
-                                       kw-34706
-                                       inits-34707
-                                       vars-34708
-                                       body-34709
-                                       else*-34714)))))))))
-                     tmp-34622)
+                                       s-34832
+                                       req-34926
+                                       opt-34927
+                                       rest-34928
+                                       kw-34929
+                                       inits-34930
+                                       vars-34931
+                                       body-34932
+                                       else*-34937)))))))))
+                     tmp-34845)
                    (syntax-violation
                      #f
                      "source expression failed to match any pattern"
-                     clauses-34612))))))))
-     (strip-4599
-       (lambda (x-35864 w-35865)
-         (if (memq 'top (car w-35865))
-           x-35864
+                     clauses-34835))))))))
+     (strip-4395
+       (lambda (x-36087 w-36088)
+         (if (memq 'top (car w-36088))
+           x-36087
            (letrec*
-             ((f-35866
-                (lambda (x-35869)
-                  (if (if (vector? x-35869)
-                        (if (= (vector-length x-35869) 4)
-                          (eq? (vector-ref x-35869 0) 'syntax-object)
+             ((f-36089
+                (lambda (x-36092)
+                  (if (if (vector? x-36092)
+                        (if (= (vector-length x-36092) 4)
+                          (eq? (vector-ref x-36092 0) 'syntax-object)
                           #f)
                         #f)
-                    (strip-4599
-                      (vector-ref x-35869 1)
-                      (vector-ref x-35869 2))
-                    (if (pair? x-35869)
-                      (let ((a-35888 (f-35866 (car x-35869)))
-                            (d-35889 (f-35866 (cdr x-35869))))
-                        (if (if (eq? a-35888 (car x-35869))
-                              (eq? d-35889 (cdr x-35869))
+                    (strip-4395
+                      (vector-ref x-36092 1)
+                      (vector-ref x-36092 2))
+                    (if (pair? x-36092)
+                      (let ((a-36111 (f-36089 (car x-36092)))
+                            (d-36112 (f-36089 (cdr x-36092))))
+                        (if (if (eq? a-36111 (car x-36092))
+                              (eq? d-36112 (cdr x-36092))
                               #f)
-                          x-35869
-                          (cons a-35888 d-35889)))
-                      (if (vector? x-35869)
-                        (let ((old-35892 (vector->list x-35869)))
-                          (let ((new-35893 (map f-35866 old-35892)))
+                          x-36092
+                          (cons a-36111 d-36112)))
+                      (if (vector? x-36092)
+                        (let ((old-36115 (vector->list x-36092)))
+                          (let ((new-36116 (map f-36089 old-36115)))
                             (letrec*
-                              ((lp-35894
-                                 (lambda (l1-35991 l2-35992)
-                                   (if (null? l1-35991)
-                                     x-35869
-                                     (if (eq? (car l1-35991) (car l2-35992))
-                                       (lp-35894 (cdr l1-35991) (cdr l2-35992))
-                                       (list->vector new-35893))))))
-                              (lp-35894 old-35892 new-35893))))
-                        x-35869))))))
-             (f-35866 x-35864)))))
-     (gen-var-4600
-       (lambda (id-34758)
-         (let ((id-34759
-                 (if (if (vector? id-34758)
-                       (if (= (vector-length id-34758) 4)
-                         (eq? (vector-ref id-34758 0) 'syntax-object)
+                              ((lp-36117
+                                 (lambda (l1-36214 l2-36215)
+                                   (if (null? l1-36214)
+                                     x-36092
+                                     (if (eq? (car l1-36214) (car l2-36215))
+                                       (lp-36117 (cdr l1-36214) (cdr l2-36215))
+                                       (list->vector new-36116))))))
+                              (lp-36117 old-36115 new-36116))))
+                        x-36092))))))
+             (f-36089 x-36087)))))
+     (gen-var-4396
+       (lambda (id-34981)
+         (let ((id-34982
+                 (if (if (vector? id-34981)
+                       (if (= (vector-length id-34981) 4)
+                         (eq? (vector-ref id-34981 0) 'syntax-object)
                          #f)
                        #f)
-                   (vector-ref id-34758 1)
-                   id-34758)))
+                   (vector-ref id-34981 1)
+                   id-34981)))
            (gensym
-             (string-append (symbol->string id-34759) "-")))))
-     (lambda-var-list-4601
-       (lambda (vars-35993)
+             (string-append (symbol->string id-34982) "-")))))
+     (lambda-var-list-4397
+       (lambda (vars-36216)
          (letrec*
-           ((lvl-35994
-              (lambda (vars-35997 ls-35998 w-35999)
-                (if (pair? vars-35997)
-                  (lvl-35994
-                    (cdr vars-35997)
-                    (cons (let ((x-36003 (car vars-35997)))
-                            (if (if (null? (car w-35999))
-                                  (null? (cdr w-35999))
+           ((lvl-36217
+              (lambda (vars-36220 ls-36221 w-36222)
+                (if (pair? vars-36220)
+                  (lvl-36217
+                    (cdr vars-36220)
+                    (cons (let ((x-36226 (car vars-36220)))
+                            (if (if (null? (car w-36222))
+                                  (null? (cdr w-36222))
                                   #f)
-                              x-36003
-                              (if (if (vector? x-36003)
-                                    (if (= (vector-length x-36003) 4)
-                                      (eq? (vector-ref x-36003 0)
+                              x-36226
+                              (if (if (vector? x-36226)
+                                    (if (= (vector-length x-36226) 4)
+                                      (eq? (vector-ref x-36226 0)
                                            'syntax-object)
                                       #f)
                                     #f)
-                                (let ((expression-36021 (vector-ref x-36003 1))
-                                      (wrap-36022
-                                        (let ((w2-36030
-                                                (vector-ref x-36003 2)))
-                                          (let ((m1-36031 (car w-35999))
-                                                (s1-36032 (cdr w-35999)))
-                                            (if (null? m1-36031)
-                                              (if (null? s1-36032)
-                                                w2-36030
-                                                (cons (car w2-36030)
-                                                      (let ((m2-36047
-                                                              (cdr w2-36030)))
-                                                        (if (null? m2-36047)
-                                                          s1-36032
+                                (let ((expression-36244 (vector-ref x-36226 1))
+                                      (wrap-36245
+                                        (let ((w2-36253
+                                                (vector-ref x-36226 2)))
+                                          (let ((m1-36254 (car w-36222))
+                                                (s1-36255 (cdr w-36222)))
+                                            (if (null? m1-36254)
+                                              (if (null? s1-36255)
+                                                w2-36253
+                                                (cons (car w2-36253)
+                                                      (let ((m2-36270
+                                                              (cdr w2-36253)))
+                                                        (if (null? m2-36270)
+                                                          s1-36255
                                                           (append
-                                                            s1-36032
-                                                            m2-36047)))))
-                                              (cons (let ((m2-36055
-                                                            (car w2-36030)))
-                                                      (if (null? m2-36055)
-                                                        m1-36031
+                                                            s1-36255
+                                                            m2-36270)))))
+                                              (cons (let ((m2-36278
+                                                            (car w2-36253)))
+                                                      (if (null? m2-36278)
+                                                        m1-36254
                                                         (append
-                                                          m1-36031
-                                                          m2-36055)))
-                                                    (let ((m2-36063
-                                                            (cdr w2-36030)))
-                                                      (if (null? m2-36063)
-                                                        s1-36032
+                                                          m1-36254
+                                                          m2-36278)))
+                                                    (let ((m2-36286
+                                                            (cdr w2-36253)))
+                                                      (if (null? m2-36286)
+                                                        s1-36255
                                                         (append
-                                                          s1-36032
-                                                          m2-36063))))))))
-                                      (module-36023 (vector-ref x-36003 3)))
+                                                          s1-36255
+                                                          m2-36286))))))))
+                                      (module-36246 (vector-ref x-36226 3)))
                                   (vector
                                     'syntax-object
-                                    expression-36021
-                                    wrap-36022
-                                    module-36023))
-                                (if (null? x-36003)
-                                  x-36003
+                                    expression-36244
+                                    wrap-36245
+                                    module-36246))
+                                (if (null? x-36226)
+                                  x-36226
                                   (vector
                                     'syntax-object
-                                    x-36003
-                                    w-35999
+                                    x-36226
+                                    w-36222
                                     #f)))))
-                          ls-35998)
-                    w-35999)
-                  (if (if (symbol? vars-35997)
+                          ls-36221)
+                    w-36222)
+                  (if (if (symbol? vars-36220)
                         #t
-                        (if (if (vector? vars-35997)
-                              (if (= (vector-length vars-35997) 4)
-                                (eq? (vector-ref vars-35997 0) 'syntax-object)
+                        (if (if (vector? vars-36220)
+                              (if (= (vector-length vars-36220) 4)
+                                (eq? (vector-ref vars-36220 0) 'syntax-object)
                                 #f)
                               #f)
-                          (symbol? (vector-ref vars-35997 1))
+                          (symbol? (vector-ref vars-36220 1))
                           #f))
-                    (cons (if (if (null? (car w-35999))
-                                (null? (cdr w-35999))
+                    (cons (if (if (null? (car w-36222))
+                                (null? (cdr w-36222))
                                 #f)
-                            vars-35997
-                            (if (if (vector? vars-35997)
-                                  (if (= (vector-length vars-35997) 4)
-                                    (eq? (vector-ref vars-35997 0)
+                            vars-36220
+                            (if (if (vector? vars-36220)
+                                  (if (= (vector-length vars-36220) 4)
+                                    (eq? (vector-ref vars-36220 0)
                                          'syntax-object)
                                     #f)
                                   #f)
-                              (let ((expression-36133
-                                      (vector-ref vars-35997 1))
-                                    (wrap-36134
-                                      (let ((w2-36144
-                                              (vector-ref vars-35997 2)))
-                                        (let ((m1-36145 (car w-35999))
-                                              (s1-36146 (cdr w-35999)))
-                                          (if (null? m1-36145)
-                                            (if (null? s1-36146)
-                                              w2-36144
-                                              (cons (car w2-36144)
-                                                    (let ((m2-36163
-                                                            (cdr w2-36144)))
-                                                      (if (null? m2-36163)
-                                                        s1-36146
+                              (let ((expression-36356
+                                      (vector-ref vars-36220 1))
+                                    (wrap-36357
+                                      (let ((w2-36367
+                                              (vector-ref vars-36220 2)))
+                                        (let ((m1-36368 (car w-36222))
+                                              (s1-36369 (cdr w-36222)))
+                                          (if (null? m1-36368)
+                                            (if (null? s1-36369)
+                                              w2-36367
+                                              (cons (car w2-36367)
+                                                    (let ((m2-36386
+                                                            (cdr w2-36367)))
+                                                      (if (null? m2-36386)
+                                                        s1-36369
                                                         (append
-                                                          s1-36146
-                                                          m2-36163)))))
-                                            (cons (let ((m2-36171
-                                                          (car w2-36144)))
-                                                    (if (null? m2-36171)
-                                                      m1-36145
+                                                          s1-36369
+                                                          m2-36386)))))
+                                            (cons (let ((m2-36394
+                                                          (car w2-36367)))
+                                                    (if (null? m2-36394)
+                                                      m1-36368
                                                       (append
-                                                        m1-36145
-                                                        m2-36171)))
-                                                  (let ((m2-36179
-                                                          (cdr w2-36144)))
-                                                    (if (null? m2-36179)
-                                                      s1-36146
+                                                        m1-36368
+                                                        m2-36394)))
+                                                  (let ((m2-36402
+                                                          (cdr w2-36367)))
+                                                    (if (null? m2-36402)
+                                                      s1-36369
                                                       (append
-                                                        s1-36146
-                                                        m2-36179))))))))
-                                    (module-36135 (vector-ref vars-35997 3)))
+                                                        s1-36369
+                                                        m2-36402))))))))
+                                    (module-36358 (vector-ref vars-36220 3)))
                                 (vector
                                   'syntax-object
-                                  expression-36133
-                                  wrap-36134
-                                  module-36135))
-                              (if (null? vars-35997)
-                                vars-35997
+                                  expression-36356
+                                  wrap-36357
+                                  module-36358))
+                              (if (null? vars-36220)
+                                vars-36220
                                 (vector
                                   'syntax-object
-                                  vars-35997
-                                  w-35999
+                                  vars-36220
+                                  w-36222
                                   #f))))
-                          ls-35998)
-                    (if (null? vars-35997)
-                      ls-35998
-                      (if (if (vector? vars-35997)
-                            (if (= (vector-length vars-35997) 4)
-                              (eq? (vector-ref vars-35997 0) 'syntax-object)
+                          ls-36221)
+                    (if (null? vars-36220)
+                      ls-36221
+                      (if (if (vector? vars-36220)
+                            (if (= (vector-length vars-36220) 4)
+                              (eq? (vector-ref vars-36220 0) 'syntax-object)
                               #f)
                             #f)
-                        (lvl-35994
-                          (vector-ref vars-35997 1)
-                          ls-35998
-                          (let ((w2-36220 (vector-ref vars-35997 2)))
-                            (let ((m1-36221 (car w-35999))
-                                  (s1-36222 (cdr w-35999)))
-                              (if (null? m1-36221)
-                                (if (null? s1-36222)
-                                  w2-36220
-                                  (cons (car w2-36220)
-                                        (let ((m2-36233 (cdr w2-36220)))
-                                          (if (null? m2-36233)
-                                            s1-36222
-                                            (append s1-36222 m2-36233)))))
-                                (cons (let ((m2-36241 (car w2-36220)))
-                                        (if (null? m2-36241)
-                                          m1-36221
-                                          (append m1-36221 m2-36241)))
-                                      (let ((m2-36249 (cdr w2-36220)))
-                                        (if (null? m2-36249)
-                                          s1-36222
-                                          (append s1-36222 m2-36249))))))))
-                        (cons vars-35997 ls-35998))))))))
-           (lvl-35994 vars-35993 '() '(()))))))
+                        (lvl-36217
+                          (vector-ref vars-36220 1)
+                          ls-36221
+                          (let ((w2-36443 (vector-ref vars-36220 2)))
+                            (let ((m1-36444 (car w-36222))
+                                  (s1-36445 (cdr w-36222)))
+                              (if (null? m1-36444)
+                                (if (null? s1-36445)
+                                  w2-36443
+                                  (cons (car w2-36443)
+                                        (let ((m2-36456 (cdr w2-36443)))
+                                          (if (null? m2-36456)
+                                            s1-36445
+                                            (append s1-36445 m2-36456)))))
+                                (cons (let ((m2-36464 (car w2-36443)))
+                                        (if (null? m2-36464)
+                                          m1-36444
+                                          (append m1-36444 m2-36464)))
+                                      (let ((m2-36472 (cdr w2-36443)))
+                                        (if (null? m2-36472)
+                                          s1-36445
+                                          (append s1-36445 m2-36472))))))))
+                        (cons vars-36220 ls-36221))))))))
+           (lvl-36217 vars-36216 '() '(()))))))
     (begin
-      (set! session-id-4511
-        (let ((v-18812
+      (set! session-id-4307
+        (let ((v-18915
                 (module-variable
                   (current-module)
                   'syntax-session-id)))
-          (lambda () ((variable-ref v-18812)))))
-      (set! transformer-environment-4572
+          (lambda () ((variable-ref v-18915)))))
+      (set! transformer-environment-4368
         (make-fluid
-          (lambda (k-17456)
+          (lambda (k-17548)
             (error "called outside the dynamic extent of a syntax 
transformer"))))
       (module-define!
         (current-module)
@@ -9324,1825 +9341,1826 @@
           'let-syntax
           'local-syntax
           #f))
-      (global-extend-4548
+      (global-extend-4344
         'core
         'syntax-parameterize
-        (lambda (e-4728 r-4729 w-4730 s-4731 mod-4732)
-          (let ((tmp-4734
+        (lambda (e-4524 r-4525 w-4526 s-4527 mod-4528)
+          (let ((tmp-4530
                   ($sc-dispatch
-                    e-4728
+                    e-4524
                     '(_ #(each (any any)) any . each-any))))
-            (if (if tmp-4734
+            (if (if tmp-4530
                   (@apply
-                    (lambda (var-4738 val-4739 e1-4740 e2-4741)
-                      (valid-bound-ids?-4576 var-4738))
-                    tmp-4734)
+                    (lambda (var-4534 val-4535 e1-4536 e2-4537)
+                      (valid-bound-ids?-4372 var-4534))
+                    tmp-4530)
                   #f)
               (@apply
-                (lambda (var-4826 val-4827 e1-4828 e2-4829)
-                  (let ((names-4830
-                          (map (lambda (x-5170)
+                (lambda (var-4622 val-4623 e1-4624 e2-4625)
+                  (let ((names-4626
+                          (map (lambda (x-4971)
                                  (call-with-values
                                    (lambda ()
-                                     (resolve-identifier-4571
-                                       x-5170
-                                       w-4730
-                                       r-4729
-                                       mod-4732
+                                     (resolve-identifier-4367
+                                       x-4971
+                                       w-4526
+                                       r-4525
+                                       mod-4528
                                        #f))
-                                   (lambda (type-5173 value-5174 mod-5175)
-                                     (if (eqv? type-5173 'displaced-lexical)
+                                   (lambda (type-4974 value-4975 mod-4976)
+                                     (if (eqv? type-4974 'displaced-lexical)
                                        (syntax-violation
                                          'syntax-parameterize
                                          "identifier out of context"
-                                         e-4728
-                                         (let ((x-5188
+                                         e-4524
+                                         (let ((x-4993
                                                  (begin
-                                                   (if (if (pair? x-5170)
-                                                         s-4731
+                                                   (if (if (pair? x-4971)
+                                                         s-4527
                                                          #f)
                                                      (set-source-properties!
-                                                       x-5170
-                                                       s-4731))
-                                                   x-5170)))
-                                           (if (if (null? (car w-4730))
-                                                 (null? (cdr w-4730))
+                                                       x-4971
+                                                       s-4527))
+                                                   x-4971)))
+                                           (if (if (null? (car w-4526))
+                                                 (null? (cdr w-4526))
                                                  #f)
-                                             x-5188
-                                             (if (if (vector? x-5188)
+                                             x-4993
+                                             (if (if (vector? x-4993)
                                                    (if (= (vector-length
-                                                            x-5188)
+                                                            x-4993)
                                                           4)
-                                                     (eq? (vector-ref x-5188 0)
+                                                     (eq? (vector-ref x-4993 0)
                                                           'syntax-object)
                                                      #f)
                                                    #f)
-                                               (let ((expression-5220
-                                                       (vector-ref x-5188 1))
-                                                     (wrap-5221
-                                                       (let ((w2-5229
+                                               (let ((expression-5025
+                                                       (vector-ref x-4993 1))
+                                                     (wrap-5026
+                                                       (let ((w2-5034
                                                                (vector-ref
-                                                                 x-5188
+                                                                 x-4993
                                                                  2)))
-                                                         (let ((m1-5230
-                                                                 (car w-4730))
-                                                               (s1-5231
-                                                                 (cdr w-4730)))
-                                                           (if (null? m1-5230)
-                                                             (if (null? 
s1-5231)
-                                                               w2-5229
-                                                               (cons (car 
w2-5229)
-                                                                     (let 
((m2-5246
-                                                                             
(cdr w2-5229)))
-                                                                       (if 
(null? m2-5246)
-                                                                         
s1-5231
+                                                         (let ((m1-5035
+                                                                 (car w-4526))
+                                                               (s1-5036
+                                                                 (cdr w-4526)))
+                                                           (if (null? m1-5035)
+                                                             (if (null? 
s1-5036)
+                                                               w2-5034
+                                                               (cons (car 
w2-5034)
+                                                                     (let 
((m2-5051
+                                                                             
(cdr w2-5034)))
+                                                                       (if 
(null? m2-5051)
+                                                                         
s1-5036
                                                                          
(append
-                                                                           
s1-5231
-                                                                           
m2-5246)))))
-                                                             (cons (let 
((m2-5254
-                                                                           
(car w2-5229)))
-                                                                     (if 
(null? m2-5254)
-                                                                       m1-5230
+                                                                           
s1-5036
+                                                                           
m2-5051)))))
+                                                             (cons (let 
((m2-5059
+                                                                           
(car w2-5034)))
+                                                                     (if 
(null? m2-5059)
+                                                                       m1-5035
                                                                        (append
-                                                                         
m1-5230
-                                                                         
m2-5254)))
-                                                                   (let 
((m2-5262
-                                                                           
(cdr w2-5229)))
-                                                                     (if 
(null? m2-5262)
-                                                                       s1-5231
+                                                                         
m1-5035
+                                                                         
m2-5059)))
+                                                                   (let 
((m2-5067
+                                                                           
(cdr w2-5034)))
+                                                                     (if 
(null? m2-5067)
+                                                                       s1-5036
                                                                        (append
-                                                                         
s1-5231
-                                                                         
m2-5262))))))))
-                                                     (module-5222
-                                                       (vector-ref x-5188 3)))
+                                                                         
s1-5036
+                                                                         
m2-5067))))))))
+                                                     (module-5027
+                                                       (vector-ref x-4993 3)))
                                                  (vector
                                                    'syntax-object
-                                                   expression-5220
-                                                   wrap-5221
-                                                   module-5222))
-                                               (if (null? x-5188)
-                                                 x-5188
+                                                   expression-5025
+                                                   wrap-5026
+                                                   module-5027))
+                                               (if (null? x-4993)
+                                                 x-4993
                                                  (vector
                                                    'syntax-object
-                                                   x-5188
-                                                   w-4730
-                                                   mod-5175))))))
-                                       (if (eqv? type-5173 'syntax-parameter)
-                                         value-5174
+                                                   x-4993
+                                                   w-4526
+                                                   mod-4976))))))
+                                       (if (eqv? type-4974 'syntax-parameter)
+                                         value-4975
                                          (syntax-violation
                                            'syntax-parameterize
                                            "invalid syntax parameter"
-                                           e-4728
-                                           (let ((x-5289
+                                           e-4524
+                                           (let ((x-5097
                                                    (begin
-                                                     (if (if (pair? x-5170)
-                                                           s-4731
+                                                     (if (if (pair? x-4971)
+                                                           s-4527
                                                            #f)
                                                        (set-source-properties!
-                                                         x-5170
-                                                         s-4731))
-                                                     x-5170)))
-                                             (if (if (null? (car w-4730))
-                                                   (null? (cdr w-4730))
+                                                         x-4971
+                                                         s-4527))
+                                                     x-4971)))
+                                             (if (if (null? (car w-4526))
+                                                   (null? (cdr w-4526))
                                                    #f)
-                                               x-5289
-                                               (if (if (vector? x-5289)
+                                               x-5097
+                                               (if (if (vector? x-5097)
                                                      (if (= (vector-length
-                                                              x-5289)
+                                                              x-5097)
                                                             4)
                                                        (eq? (vector-ref
-                                                              x-5289
+                                                              x-5097
                                                               0)
                                                             'syntax-object)
                                                        #f)
                                                      #f)
-                                                 (let ((expression-5321
-                                                         (vector-ref x-5289 1))
-                                                       (wrap-5322
-                                                         (let ((w2-5330
+                                                 (let ((expression-5129
+                                                         (vector-ref x-5097 1))
+                                                       (wrap-5130
+                                                         (let ((w2-5138
                                                                  (vector-ref
-                                                                   x-5289
+                                                                   x-5097
                                                                    2)))
-                                                           (let ((m1-5331
-                                                                   (car 
w-4730))
-                                                                 (s1-5332
-                                                                   (cdr 
w-4730)))
-                                                             (if (null? 
m1-5331)
-                                                               (if (null? 
s1-5332)
-                                                                 w2-5330
-                                                                 (cons (car 
w2-5330)
-                                                                       (let 
((m2-5347
-                                                                               
(cdr w2-5330)))
-                                                                         (if 
(null? m2-5347)
-                                                                           
s1-5332
+                                                           (let ((m1-5139
+                                                                   (car 
w-4526))
+                                                                 (s1-5140
+                                                                   (cdr 
w-4526)))
+                                                             (if (null? 
m1-5139)
+                                                               (if (null? 
s1-5140)
+                                                                 w2-5138
+                                                                 (cons (car 
w2-5138)
+                                                                       (let 
((m2-5155
+                                                                               
(cdr w2-5138)))
+                                                                         (if 
(null? m2-5155)
+                                                                           
s1-5140
                                                                            
(append
-                                                                             
s1-5332
-                                                                             
m2-5347)))))
-                                                               (cons (let 
((m2-5355
-                                                                             
(car w2-5330)))
-                                                                       (if 
(null? m2-5355)
-                                                                         
m1-5331
+                                                                             
s1-5140
+                                                                             
m2-5155)))))
+                                                               (cons (let 
((m2-5163
+                                                                             
(car w2-5138)))
+                                                                       (if 
(null? m2-5163)
+                                                                         
m1-5139
                                                                          
(append
-                                                                           
m1-5331
-                                                                           
m2-5355)))
-                                                                     (let 
((m2-5363
-                                                                             
(cdr w2-5330)))
-                                                                       (if 
(null? m2-5363)
-                                                                         
s1-5332
+                                                                           
m1-5139
+                                                                           
m2-5163)))
+                                                                     (let 
((m2-5171
+                                                                             
(cdr w2-5138)))
+                                                                       (if 
(null? m2-5171)
+                                                                         
s1-5140
                                                                          
(append
-                                                                           
s1-5332
-                                                                           
m2-5363))))))))
-                                                       (module-5323
+                                                                           
s1-5140
+                                                                           
m2-5171))))))))
+                                                       (module-5131
                                                          (vector-ref
-                                                           x-5289
+                                                           x-5097
                                                            3)))
                                                    (vector
                                                      'syntax-object
-                                                     expression-5321
-                                                     wrap-5322
-                                                     module-5323))
-                                                 (if (null? x-5289)
-                                                   x-5289
+                                                     expression-5129
+                                                     wrap-5130
+                                                     module-5131))
+                                                 (if (null? x-5097)
+                                                   x-5097
                                                    (vector
                                                      'syntax-object
-                                                     x-5289
-                                                     w-4730
-                                                     mod-5175)))))))))))
-                               var-4826))
-                        (bindings-4831
-                          (let ((trans-r-5378 (macros-only-env-4547 r-4729)))
-                            (map (lambda (x-5379)
+                                                     x-5097
+                                                     w-4526
+                                                     mod-4976)))))))))))
+                               var-4622))
+                        (bindings-4627
+                          (let ((trans-r-5186 (macros-only-env-4343 r-4525)))
+                            (map (lambda (x-5187)
                                    (cons 'macro
-                                         (eval-local-transformer-4592
-                                           (expand-4586
-                                             x-5379
-                                             trans-r-5378
-                                             w-4730
-                                             mod-4732)
-                                           mod-4732)))
-                                 val-4827))))
-                    (expand-body-4590
-                      (cons e1-4828 e2-4829)
-                      (let ((x-4843
+                                         (eval-local-transformer-4388
+                                           (expand-4382
+                                             x-5187
+                                             trans-r-5186
+                                             w-4526
+                                             mod-4528)
+                                           mod-4528)))
+                                 val-4623))))
+                    (expand-body-4386
+                      (cons e1-4624 e2-4625)
+                      (let ((x-4639
                               (begin
-                                (if (if (pair? e-4728) s-4731 #f)
-                                  (set-source-properties! e-4728 s-4731))
-                                e-4728)))
-                        (if (if (null? (car w-4730)) (null? (cdr w-4730)) #f)
-                          x-4843
-                          (if (if (vector? x-4843)
-                                (if (= (vector-length x-4843) 4)
-                                  (eq? (vector-ref x-4843 0) 'syntax-object)
+                                (if (if (pair? e-4524) s-4527 #f)
+                                  (set-source-properties! e-4524 s-4527))
+                                e-4524)))
+                        (if (if (null? (car w-4526)) (null? (cdr w-4526)) #f)
+                          x-4639
+                          (if (if (vector? x-4639)
+                                (if (= (vector-length x-4639) 4)
+                                  (eq? (vector-ref x-4639 0) 'syntax-object)
                                   #f)
                                 #f)
-                            (let ((expression-4875 (vector-ref x-4843 1))
-                                  (wrap-4876
-                                    (let ((w2-4884 (vector-ref x-4843 2)))
-                                      (let ((m1-4885 (car w-4730))
-                                            (s1-4886 (cdr w-4730)))
-                                        (if (null? m1-4885)
-                                          (if (null? s1-4886)
-                                            w2-4884
-                                            (cons (car w2-4884)
-                                                  (let ((m2-4901
-                                                          (cdr w2-4884)))
-                                                    (if (null? m2-4901)
-                                                      s1-4886
+                            (let ((expression-4671 (vector-ref x-4639 1))
+                                  (wrap-4672
+                                    (let ((w2-4680 (vector-ref x-4639 2)))
+                                      (let ((m1-4681 (car w-4526))
+                                            (s1-4682 (cdr w-4526)))
+                                        (if (null? m1-4681)
+                                          (if (null? s1-4682)
+                                            w2-4680
+                                            (cons (car w2-4680)
+                                                  (let ((m2-4697
+                                                          (cdr w2-4680)))
+                                                    (if (null? m2-4697)
+                                                      s1-4682
                                                       (append
-                                                        s1-4886
-                                                        m2-4901)))))
-                                          (cons (let ((m2-4909 (car w2-4884)))
-                                                  (if (null? m2-4909)
-                                                    m1-4885
-                                                    (append m1-4885 m2-4909)))
-                                                (let ((m2-4917 (cdr w2-4884)))
-                                                  (if (null? m2-4917)
-                                                    s1-4886
+                                                        s1-4682
+                                                        m2-4697)))))
+                                          (cons (let ((m2-4705 (car w2-4680)))
+                                                  (if (null? m2-4705)
+                                                    m1-4681
+                                                    (append m1-4681 m2-4705)))
+                                                (let ((m2-4713 (cdr w2-4680)))
+                                                  (if (null? m2-4713)
+                                                    s1-4682
                                                     (append
-                                                      s1-4886
-                                                      m2-4917))))))))
-                                  (module-4877 (vector-ref x-4843 3)))
+                                                      s1-4682
+                                                      m2-4713))))))))
+                                  (module-4673 (vector-ref x-4639 3)))
                               (vector
                                 'syntax-object
-                                expression-4875
-                                wrap-4876
-                                module-4877))
-                            (if (null? x-4843)
-                              x-4843
+                                expression-4671
+                                wrap-4672
+                                module-4673))
+                            (if (null? x-4639)
+                              x-4639
                               (vector
                                 'syntax-object
-                                x-4843
-                                w-4730
-                                mod-4732)))))
-                      (extend-env-4545 names-4830 bindings-4831 r-4729)
-                      w-4730
-                      mod-4732)))
-                tmp-4734)
+                                x-4639
+                                w-4526
+                                mod-4528)))))
+                      (extend-env-4341 names-4626 bindings-4627 r-4525)
+                      w-4526
+                      mod-4528)))
+                tmp-4530)
               (syntax-violation
                 'syntax-parameterize
                 "bad syntax"
-                (let ((x-5599
+                (let ((x-5407
                         (begin
-                          (if (if (pair? e-4728) s-4731 #f)
-                            (set-source-properties! e-4728 s-4731))
-                          e-4728)))
-                  (if (if (null? (car w-4730)) (null? (cdr w-4730)) #f)
-                    x-5599
-                    (if (if (vector? x-5599)
-                          (if (= (vector-length x-5599) 4)
-                            (eq? (vector-ref x-5599 0) 'syntax-object)
+                          (if (if (pair? e-4524) s-4527 #f)
+                            (set-source-properties! e-4524 s-4527))
+                          e-4524)))
+                  (if (if (null? (car w-4526)) (null? (cdr w-4526)) #f)
+                    x-5407
+                    (if (if (vector? x-5407)
+                          (if (= (vector-length x-5407) 4)
+                            (eq? (vector-ref x-5407 0) 'syntax-object)
                             #f)
                           #f)
-                      (let ((expression-5631 (vector-ref x-5599 1))
-                            (wrap-5632
-                              (let ((w2-5640 (vector-ref x-5599 2)))
-                                (let ((m1-5641 (car w-4730))
-                                      (s1-5642 (cdr w-4730)))
-                                  (if (null? m1-5641)
-                                    (if (null? s1-5642)
-                                      w2-5640
-                                      (cons (car w2-5640)
-                                            (let ((m2-5657 (cdr w2-5640)))
-                                              (if (null? m2-5657)
-                                                s1-5642
-                                                (append s1-5642 m2-5657)))))
-                                    (cons (let ((m2-5665 (car w2-5640)))
-                                            (if (null? m2-5665)
-                                              m1-5641
-                                              (append m1-5641 m2-5665)))
-                                          (let ((m2-5673 (cdr w2-5640)))
-                                            (if (null? m2-5673)
-                                              s1-5642
-                                              (append s1-5642 m2-5673))))))))
-                            (module-5633 (vector-ref x-5599 3)))
+                      (let ((expression-5439 (vector-ref x-5407 1))
+                            (wrap-5440
+                              (let ((w2-5448 (vector-ref x-5407 2)))
+                                (let ((m1-5449 (car w-4526))
+                                      (s1-5450 (cdr w-4526)))
+                                  (if (null? m1-5449)
+                                    (if (null? s1-5450)
+                                      w2-5448
+                                      (cons (car w2-5448)
+                                            (let ((m2-5465 (cdr w2-5448)))
+                                              (if (null? m2-5465)
+                                                s1-5450
+                                                (append s1-5450 m2-5465)))))
+                                    (cons (let ((m2-5473 (car w2-5448)))
+                                            (if (null? m2-5473)
+                                              m1-5449
+                                              (append m1-5449 m2-5473)))
+                                          (let ((m2-5481 (cdr w2-5448)))
+                                            (if (null? m2-5481)
+                                              s1-5450
+                                              (append s1-5450 m2-5481))))))))
+                            (module-5441 (vector-ref x-5407 3)))
                         (vector
                           'syntax-object
-                          expression-5631
-                          wrap-5632
-                          module-5633))
-                      (if (null? x-5599)
-                        x-5599
-                        (vector 'syntax-object x-5599 w-4730 mod-4732))))))))))
+                          expression-5439
+                          wrap-5440
+                          module-5441))
+                      (if (null? x-5407)
+                        x-5407
+                        (vector 'syntax-object x-5407 w-4526 mod-4528))))))))))
       (module-define!
         (current-module)
         'quote
         (make-syntax-transformer
           'quote
           'core
-          (lambda (e-5701 r-5702 w-5703 s-5704 mod-5705)
-            (let ((tmp-5707 ($sc-dispatch e-5701 '(_ any))))
-              (if tmp-5707
+          (lambda (e-5509 r-5510 w-5511 s-5512 mod-5513)
+            (let ((tmp-5515 ($sc-dispatch e-5509 '(_ any))))
+              (if tmp-5515
                 (@apply
-                  (lambda (e-5710)
-                    (let ((exp-5714 (strip-4599 e-5710 w-5703)))
+                  (lambda (e-5518)
+                    (let ((exp-5522 (strip-4395 e-5518 w-5511)))
                       (make-struct/no-tail
                         (vector-ref %expanded-vtables 1)
-                        s-5704
-                        exp-5714)))
-                  tmp-5707)
+                        s-5512
+                        exp-5522)))
+                  tmp-5515)
                 (syntax-violation
                   'quote
                   "bad syntax"
-                  (let ((x-5728
+                  (let ((x-5536
                           (begin
-                            (if (if (pair? e-5701) s-5704 #f)
-                              (set-source-properties! e-5701 s-5704))
-                            e-5701)))
-                    (if (if (null? (car w-5703)) (null? (cdr w-5703)) #f)
-                      x-5728
-                      (if (if (vector? x-5728)
-                            (if (= (vector-length x-5728) 4)
-                              (eq? (vector-ref x-5728 0) 'syntax-object)
+                            (if (if (pair? e-5509) s-5512 #f)
+                              (set-source-properties! e-5509 s-5512))
+                            e-5509)))
+                    (if (if (null? (car w-5511)) (null? (cdr w-5511)) #f)
+                      x-5536
+                      (if (if (vector? x-5536)
+                            (if (= (vector-length x-5536) 4)
+                              (eq? (vector-ref x-5536 0) 'syntax-object)
                               #f)
                             #f)
-                        (let ((expression-5760 (vector-ref x-5728 1))
-                              (wrap-5761
-                                (let ((w2-5769 (vector-ref x-5728 2)))
-                                  (let ((m1-5770 (car w-5703))
-                                        (s1-5771 (cdr w-5703)))
-                                    (if (null? m1-5770)
-                                      (if (null? s1-5771)
-                                        w2-5769
-                                        (cons (car w2-5769)
-                                              (let ((m2-5786 (cdr w2-5769)))
-                                                (if (null? m2-5786)
-                                                  s1-5771
-                                                  (append s1-5771 m2-5786)))))
-                                      (cons (let ((m2-5794 (car w2-5769)))
-                                              (if (null? m2-5794)
-                                                m1-5770
-                                                (append m1-5770 m2-5794)))
-                                            (let ((m2-5802 (cdr w2-5769)))
-                                              (if (null? m2-5802)
-                                                s1-5771
-                                                (append s1-5771 m2-5802))))))))
-                              (module-5762 (vector-ref x-5728 3)))
+                        (let ((expression-5568 (vector-ref x-5536 1))
+                              (wrap-5569
+                                (let ((w2-5577 (vector-ref x-5536 2)))
+                                  (let ((m1-5578 (car w-5511))
+                                        (s1-5579 (cdr w-5511)))
+                                    (if (null? m1-5578)
+                                      (if (null? s1-5579)
+                                        w2-5577
+                                        (cons (car w2-5577)
+                                              (let ((m2-5594 (cdr w2-5577)))
+                                                (if (null? m2-5594)
+                                                  s1-5579
+                                                  (append s1-5579 m2-5594)))))
+                                      (cons (let ((m2-5602 (car w2-5577)))
+                                              (if (null? m2-5602)
+                                                m1-5578
+                                                (append m1-5578 m2-5602)))
+                                            (let ((m2-5610 (cdr w2-5577)))
+                                              (if (null? m2-5610)
+                                                s1-5579
+                                                (append s1-5579 m2-5610))))))))
+                              (module-5570 (vector-ref x-5536 3)))
                           (vector
                             'syntax-object
-                            expression-5760
-                            wrap-5761
-                            module-5762))
-                        (if (null? x-5728)
-                          x-5728
+                            expression-5568
+                            wrap-5569
+                            module-5570))
+                        (if (null? x-5536)
+                          x-5536
                           (vector
                             'syntax-object
-                            x-5728
-                            w-5703
-                            mod-5705)))))))))))
-      (global-extend-4548
+                            x-5536
+                            w-5511
+                            mod-5513)))))))))))
+      (global-extend-4344
         'core
         'syntax
         (letrec*
-          ((gen-syntax-6020
-             (lambda (src-6451
-                      e-6452
-                      r-6453
-                      maps-6454
-                      ellipsis?-6455
-                      mod-6456)
-               (if (if (symbol? e-6452)
+          ((gen-syntax-5829
+             (lambda (src-6260
+                      e-6261
+                      r-6262
+                      maps-6263
+                      ellipsis?-6264
+                      mod-6265)
+               (if (if (symbol? e-6261)
                      #t
-                     (if (if (vector? e-6452)
-                           (if (= (vector-length e-6452) 4)
-                             (eq? (vector-ref e-6452 0) 'syntax-object)
+                     (if (if (vector? e-6261)
+                           (if (= (vector-length e-6261) 4)
+                             (eq? (vector-ref e-6261 0) 'syntax-object)
                              #f)
                            #f)
-                       (symbol? (vector-ref e-6452 1))
+                       (symbol? (vector-ref e-6261 1))
                        #f))
                  (call-with-values
                    (lambda ()
-                     (resolve-identifier-4571
-                       e-6452
+                     (resolve-identifier-4367
+                       e-6261
                        '(())
-                       r-6453
-                       mod-6456
+                       r-6262
+                       mod-6265
                        #f))
-                   (lambda (type-6485 value-6486 mod-6487)
-                     (if (eqv? type-6485 'syntax)
+                   (lambda (type-6294 value-6295 mod-6296)
+                     (if (eqv? type-6294 'syntax)
                        (call-with-values
                          (lambda ()
-                           (gen-ref-6021
-                             src-6451
-                             (car value-6486)
-                             (cdr value-6486)
-                             maps-6454))
-                         (lambda (var-6493 maps-6494)
-                           (values (list 'ref var-6493) maps-6494)))
-                       (if (ellipsis?-6455 e-6452)
+                           (gen-ref-5830
+                             src-6260
+                             (car value-6295)
+                             (cdr value-6295)
+                             maps-6263))
+                         (lambda (var-6304 maps-6305)
+                           (values (list 'ref var-6304) maps-6305)))
+                       (if (ellipsis?-6264 e-6261)
                          (syntax-violation
                            'syntax
                            "misplaced ellipsis"
-                           src-6451)
-                         (values (list 'quote e-6452) maps-6454)))))
-                 (let ((tmp-6496 ($sc-dispatch e-6452 '(any any))))
-                   (if (if tmp-6496
+                           src-6260)
+                         (values (list 'quote e-6261) maps-6263)))))
+                 (let ((tmp-6307 ($sc-dispatch e-6261 '(any any))))
+                   (if (if tmp-6307
                          (@apply
-                           (lambda (dots-6500 e-6501)
-                             (ellipsis?-6455 dots-6500))
-                           tmp-6496)
+                           (lambda (dots-6311 e-6312)
+                             (ellipsis?-6264 dots-6311))
+                           tmp-6307)
                          #f)
                      (@apply
-                       (lambda (dots-6502 e-6503)
-                         (gen-syntax-6020
-                           src-6451
-                           e-6503
-                           r-6453
-                           maps-6454
-                           (lambda (x-6504) #f)
-                           mod-6456))
-                       tmp-6496)
-                     (let ((tmp-6505 ($sc-dispatch e-6452 '(any any . any))))
-                       (if (if tmp-6505
+                       (lambda (dots-6313 e-6314)
+                         (gen-syntax-5829
+                           src-6260
+                           e-6314
+                           r-6262
+                           maps-6263
+                           (lambda (x-6315) #f)
+                           mod-6265))
+                       tmp-6307)
+                     (let ((tmp-6316 ($sc-dispatch e-6261 '(any any . any))))
+                       (if (if tmp-6316
                              (@apply
-                               (lambda (x-6509 dots-6510 y-6511)
-                                 (ellipsis?-6455 dots-6510))
-                               tmp-6505)
+                               (lambda (x-6320 dots-6321 y-6322)
+                                 (ellipsis?-6264 dots-6321))
+                               tmp-6316)
                              #f)
                          (@apply
-                           (lambda (x-6512 dots-6513 y-6514)
+                           (lambda (x-6323 dots-6324 y-6325)
                              (letrec*
-                               ((f-6515
-                                  (lambda (y-6523 k-6524)
-                                    (let ((tmp-6526
+                               ((f-6326
+                                  (lambda (y-6334 k-6335)
+                                    (let ((tmp-6337
                                             ($sc-dispatch
-                                              y-6523
+                                              y-6334
                                               '(any . any))))
-                                      (if (if tmp-6526
+                                      (if (if tmp-6337
                                             (@apply
-                                              (lambda (dots-6530 y-6531)
-                                                (ellipsis?-6455 dots-6530))
-                                              tmp-6526)
+                                              (lambda (dots-6341 y-6342)
+                                                (ellipsis?-6264 dots-6341))
+                                              tmp-6337)
                                             #f)
                                         (@apply
-                                          (lambda (dots-6532 y-6533)
-                                            (f-6515
-                                              y-6533
-                                              (lambda (maps-6534)
+                                          (lambda (dots-6343 y-6344)
+                                            (f-6326
+                                              y-6344
+                                              (lambda (maps-6345)
                                                 (call-with-values
                                                   (lambda ()
-                                                    (k-6524
-                                                      (cons '() maps-6534)))
-                                                  (lambda (x-6535 maps-6536)
-                                                    (if (null? (car maps-6536))
+                                                    (k-6335
+                                                      (cons '() maps-6345)))
+                                                  (lambda (x-6346 maps-6347)
+                                                    (if (null? (car maps-6347))
                                                       (syntax-violation
                                                         'syntax
                                                         "extra ellipsis"
-                                                        src-6451)
+                                                        src-6260)
                                                       (values
-                                                        (let ((map-env-6540
-                                                                (car 
maps-6536)))
+                                                        (let ((map-env-6351
+                                                                (car 
maps-6347)))
                                                           (list 'apply
                                                                 '(primitive
                                                                    append)
-                                                                (gen-map-6023
-                                                                  x-6535
-                                                                  
map-env-6540)))
-                                                        (cdr maps-6536))))))))
-                                          tmp-6526)
+                                                                (gen-map-5832
+                                                                  x-6346
+                                                                  
map-env-6351)))
+                                                        (cdr maps-6347))))))))
+                                          tmp-6337)
                                         (call-with-values
                                           (lambda ()
-                                            (gen-syntax-6020
-                                              src-6451
-                                              y-6523
-                                              r-6453
-                                              maps-6454
-                                              ellipsis?-6455
-                                              mod-6456))
-                                          (lambda (y-6543 maps-6544)
+                                            (gen-syntax-5829
+                                              src-6260
+                                              y-6334
+                                              r-6262
+                                              maps-6263
+                                              ellipsis?-6264
+                                              mod-6265))
+                                          (lambda (y-6354 maps-6355)
                                             (call-with-values
-                                              (lambda () (k-6524 maps-6544))
-                                              (lambda (x-6545 maps-6546)
+                                              (lambda () (k-6335 maps-6355))
+                                              (lambda (x-6356 maps-6357)
                                                 (values
-                                                  (if (equal? y-6543 ''())
-                                                    x-6545
+                                                  (if (equal? y-6354 ''())
+                                                    x-6356
                                                     (list 'append
-                                                          x-6545
-                                                          y-6543))
-                                                  maps-6546))))))))))
-                               (f-6515
-                                 y-6514
-                                 (lambda (maps-6518)
+                                                          x-6356
+                                                          y-6354))
+                                                  maps-6357))))))))))
+                               (f-6326
+                                 y-6325
+                                 (lambda (maps-6329)
                                    (call-with-values
                                      (lambda ()
-                                       (gen-syntax-6020
-                                         src-6451
-                                         x-6512
-                                         r-6453
-                                         (cons '() maps-6518)
-                                         ellipsis?-6455
-                                         mod-6456))
-                                     (lambda (x-6519 maps-6520)
-                                       (if (null? (car maps-6520))
+                                       (gen-syntax-5829
+                                         src-6260
+                                         x-6323
+                                         r-6262
+                                         (cons '() maps-6329)
+                                         ellipsis?-6264
+                                         mod-6265))
+                                     (lambda (x-6330 maps-6331)
+                                       (if (null? (car maps-6331))
                                          (syntax-violation
                                            'syntax
                                            "extra ellipsis"
-                                           src-6451)
+                                           src-6260)
                                          (values
-                                           (gen-map-6023
-                                             x-6519
-                                             (car maps-6520))
-                                           (cdr maps-6520)))))))))
-                           tmp-6505)
-                         (let ((tmp-6562 ($sc-dispatch e-6452 '(any . any))))
-                           (if tmp-6562
+                                           (gen-map-5832
+                                             x-6330
+                                             (car maps-6331))
+                                           (cdr maps-6331)))))))))
+                           tmp-6316)
+                         (let ((tmp-6373 ($sc-dispatch e-6261 '(any . any))))
+                           (if tmp-6373
                              (@apply
-                               (lambda (x-6566 y-6567)
+                               (lambda (x-6377 y-6378)
                                  (call-with-values
                                    (lambda ()
-                                     (gen-syntax-6020
-                                       src-6451
-                                       x-6566
-                                       r-6453
-                                       maps-6454
-                                       ellipsis?-6455
-                                       mod-6456))
-                                   (lambda (x-6568 maps-6569)
+                                     (gen-syntax-5829
+                                       src-6260
+                                       x-6377
+                                       r-6262
+                                       maps-6263
+                                       ellipsis?-6264
+                                       mod-6265))
+                                   (lambda (x-6379 maps-6380)
                                      (call-with-values
                                        (lambda ()
-                                         (gen-syntax-6020
-                                           src-6451
-                                           y-6567
-                                           r-6453
-                                           maps-6569
-                                           ellipsis?-6455
-                                           mod-6456))
-                                       (lambda (y-6570 maps-6571)
+                                         (gen-syntax-5829
+                                           src-6260
+                                           y-6378
+                                           r-6262
+                                           maps-6380
+                                           ellipsis?-6264
+                                           mod-6265))
+                                       (lambda (y-6381 maps-6382)
                                          (values
-                                           (let ((atom-key-6576 (car y-6570)))
-                                             (if (eqv? atom-key-6576 'quote)
-                                               (if (eq? (car x-6568) 'quote)
+                                           (let ((key-6387 (car y-6381)))
+                                             (if (eqv? key-6387 'quote)
+                                               (if (eq? (car x-6379) 'quote)
                                                  (list 'quote
-                                                       (cons (car (cdr x-6568))
-                                                             (car (cdr 
y-6570))))
-                                                 (if (eq? (car (cdr y-6570))
+                                                       (cons (car (cdr x-6379))
+                                                             (car (cdr 
y-6381))))
+                                                 (if (eq? (car (cdr y-6381))
                                                           '())
-                                                   (list 'list x-6568)
-                                                   (list 'cons x-6568 y-6570)))
-                                               (if (eqv? atom-key-6576 'list)
+                                                   (list 'list x-6379)
+                                                   (list 'cons x-6379 y-6381)))
+                                               (if (eqv? key-6387 'list)
                                                  (cons 'list
-                                                       (cons x-6568
-                                                             (cdr y-6570)))
-                                                 (list 'cons x-6568 y-6570))))
-                                           maps-6571))))))
-                               tmp-6562)
-                             (let ((tmp-6605
+                                                       (cons x-6379
+                                                             (cdr y-6381)))
+                                                 (list 'cons x-6379 y-6381))))
+                                           maps-6382))))))
+                               tmp-6373)
+                             (let ((tmp-6416
                                      ($sc-dispatch
-                                       e-6452
+                                       e-6261
                                        '#(vector (any . each-any)))))
-                               (if tmp-6605
+                               (if tmp-6416
                                  (@apply
-                                   (lambda (e1-6609 e2-6610)
+                                   (lambda (e1-6420 e2-6421)
                                      (call-with-values
                                        (lambda ()
-                                         (gen-syntax-6020
-                                           src-6451
-                                           (cons e1-6609 e2-6610)
-                                           r-6453
-                                           maps-6454
-                                           ellipsis?-6455
-                                           mod-6456))
-                                       (lambda (e-6611 maps-6612)
+                                         (gen-syntax-5829
+                                           src-6260
+                                           (cons e1-6420 e2-6421)
+                                           r-6262
+                                           maps-6263
+                                           ellipsis?-6264
+                                           mod-6265))
+                                       (lambda (e-6422 maps-6423)
                                          (values
-                                           (if (eq? (car e-6611) 'list)
-                                             (cons 'vector (cdr e-6611))
-                                             (if (eq? (car e-6611) 'quote)
+                                           (if (eq? (car e-6422) 'list)
+                                             (cons 'vector (cdr e-6422))
+                                             (if (eq? (car e-6422) 'quote)
                                                (list 'quote
                                                      (list->vector
-                                                       (car (cdr e-6611))))
-                                               (list 'list->vector e-6611)))
-                                           maps-6612))))
-                                   tmp-6605)
+                                                       (car (cdr e-6422))))
+                                               (list 'list->vector e-6422)))
+                                           maps-6423))))
+                                   tmp-6416)
                                  (values
-                                   (list 'quote e-6452)
-                                   maps-6454))))))))))))
-           (gen-ref-6021
-             (lambda (src-6639 var-6640 level-6641 maps-6642)
-               (if (= level-6641 0)
-                 (values var-6640 maps-6642)
-                 (if (null? maps-6642)
+                                   (list 'quote e-6261)
+                                   maps-6263))))))))))))
+           (gen-ref-5830
+             (lambda (src-6450 var-6451 level-6452 maps-6453)
+               (if (= level-6452 0)
+                 (values var-6451 maps-6453)
+                 (if (null? maps-6453)
                    (syntax-violation
                      'syntax
                      "missing ellipsis"
-                     src-6639)
+                     src-6450)
                    (call-with-values
                      (lambda ()
-                       (gen-ref-6021
-                         src-6639
-                         var-6640
-                         (#{1-}# level-6641)
-                         (cdr maps-6642)))
-                     (lambda (outer-var-6643 outer-maps-6644)
-                       (let ((b-6645 (assq outer-var-6643 (car maps-6642))))
-                         (if b-6645
-                           (values (cdr b-6645) maps-6642)
-                           (let ((inner-var-6647
+                       (gen-ref-5830
+                         src-6450
+                         var-6451
+                         (#{1-}# level-6452)
+                         (cdr maps-6453)))
+                     (lambda (outer-var-6454 outer-maps-6455)
+                       (let ((b-6456 (assq outer-var-6454 (car maps-6453))))
+                         (if b-6456
+                           (values (cdr b-6456) maps-6453)
+                           (let ((inner-var-6458
                                    (gensym
                                      (string-append
                                        (symbol->string 'tmp)
                                        "-"))))
                              (values
-                               inner-var-6647
-                               (cons (cons (cons outer-var-6643 inner-var-6647)
-                                           (car maps-6642))
-                                     outer-maps-6644)))))))))))
-           (gen-map-6023
-             (lambda (e-6661 map-env-6662)
-               (let ((formals-6663 (map cdr map-env-6662))
-                     (actuals-6664
-                       (map (lambda (x-6666) (list 'ref (car x-6666)))
-                            map-env-6662)))
-                 (if (eq? (car e-6661) 'ref)
-                   (car actuals-6664)
+                               inner-var-6458
+                               (cons (cons (cons outer-var-6454 inner-var-6458)
+                                           (car maps-6453))
+                                     outer-maps-6455)))))))))))
+           (gen-map-5832
+             (lambda (e-6472 map-env-6473)
+               (let ((formals-6474 (map cdr map-env-6473))
+                     (actuals-6475
+                       (map (lambda (x-6477) (list 'ref (car x-6477)))
+                            map-env-6473)))
+                 (if (eq? (car e-6472) 'ref)
+                   (car actuals-6475)
                    (if (and-map
-                         (lambda (x-6667)
-                           (if (eq? (car x-6667) 'ref)
-                             (memq (car (cdr x-6667)) formals-6663)
+                         (lambda (x-6478)
+                           (if (eq? (car x-6478) 'ref)
+                             (memq (car (cdr x-6478)) formals-6474)
                              #f))
-                         (cdr e-6661))
+                         (cdr e-6472))
                      (cons 'map
-                           (cons (list 'primitive (car e-6661))
-                                 (map (let ((r-6669
+                           (cons (list 'primitive (car e-6472))
+                                 (map (let ((r-6480
                                               (map cons
-                                                   formals-6663
-                                                   actuals-6664)))
-                                        (lambda (x-6670)
-                                          (cdr (assq (car (cdr x-6670))
-                                                     r-6669))))
-                                      (cdr e-6661))))
+                                                   formals-6474
+                                                   actuals-6475)))
+                                        (lambda (x-6481)
+                                          (cdr (assq (car (cdr x-6481))
+                                                     r-6480))))
+                                      (cdr e-6472))))
                      (cons 'map
-                           (cons (list 'lambda formals-6663 e-6661)
-                                 actuals-6664)))))))
-           (regen-6027
-             (lambda (x-6672)
-               (let ((atom-key-6673 (car x-6672)))
-                 (if (eqv? atom-key-6673 'ref)
-                   (let ((name-6683 (car (cdr x-6672)))
-                         (var-6684 (car (cdr x-6672))))
+                           (cons (list 'lambda formals-6474 e-6472)
+                                 actuals-6475)))))))
+           (regen-5836
+             (lambda (x-6483)
+               (let ((key-6484 (car x-6483)))
+                 (if (eqv? key-6484 'ref)
+                   (let ((name-6494 (car (cdr x-6483)))
+                         (var-6495 (car (cdr x-6483))))
                      (make-struct/no-tail
                        (vector-ref %expanded-vtables 3)
                        #f
-                       name-6683
-                       var-6684))
-                   (if (eqv? atom-key-6673 'primitive)
-                     (let ((name-6695 (car (cdr x-6672))))
+                       name-6494
+                       var-6495))
+                   (if (eqv? key-6484 'primitive)
+                     (let ((name-6506 (car (cdr x-6483))))
                        (make-struct/no-tail
                          (vector-ref %expanded-vtables 2)
                          #f
-                         name-6695))
-                     (if (eqv? atom-key-6673 'quote)
-                       (let ((exp-6706 (car (cdr x-6672))))
+                         name-6506))
+                     (if (eqv? key-6484 'quote)
+                       (let ((exp-6517 (car (cdr x-6483))))
                          (make-struct/no-tail
                            (vector-ref %expanded-vtables 1)
                            #f
-                           exp-6706))
-                       (if (eqv? atom-key-6673 'lambda)
-                         (if (list? (car (cdr x-6672)))
-                           (let ((req-6717 (car (cdr x-6672)))
-                                 (vars-6719 (car (cdr x-6672)))
-                                 (exp-6721
-                                   (regen-6027 (car (cdr (cdr x-6672))))))
-                             (let ((body-6726
+                           exp-6517))
+                       (if (eqv? key-6484 'lambda)
+                         (if (list? (car (cdr x-6483)))
+                           (let ((req-6528 (car (cdr x-6483)))
+                                 (vars-6530 (car (cdr x-6483)))
+                                 (exp-6532
+                                   (regen-5836 (car (cdr (cdr x-6483))))))
+                             (let ((body-6537
                                      (make-struct/no-tail
                                        (vector-ref %expanded-vtables 15)
                                        #f
-                                       req-6717
+                                       req-6528
                                        #f
                                        #f
                                        #f
                                        '()
-                                       vars-6719
-                                       exp-6721
+                                       vars-6530
+                                       exp-6532
                                        #f)))
                                (make-struct/no-tail
                                  (vector-ref %expanded-vtables 14)
                                  #f
                                  '()
-                                 body-6726)))
-                           (error "how did we get here" x-6672))
-                         (let ((name-6742 (car x-6672))
-                               (args-6743 (map regen-6027 (cdr x-6672))))
+                                 body-6537)))
+                           (error "how did we get here" x-6483))
+                         (let ((name-6553 (car x-6483))
+                               (args-6554 (map regen-5836 (cdr x-6483))))
                            (make-struct/no-tail
                              (vector-ref %expanded-vtables 12)
                              #f
-                             name-6742
-                             args-6743))))))))))
-          (lambda (e-6028 r-6029 w-6030 s-6031 mod-6032)
-            (let ((e-6033
-                    (let ((x-6362
+                             name-6553
+                             args-6554))))))))))
+          (lambda (e-5837 r-5838 w-5839 s-5840 mod-5841)
+            (let ((e-5842
+                    (let ((x-6171
                             (begin
-                              (if (if (pair? e-6028) s-6031 #f)
-                                (set-source-properties! e-6028 s-6031))
-                              e-6028)))
-                      (if (if (null? (car w-6030)) (null? (cdr w-6030)) #f)
-                        x-6362
-                        (if (if (vector? x-6362)
-                              (if (= (vector-length x-6362) 4)
-                                (eq? (vector-ref x-6362 0) 'syntax-object)
+                              (if (if (pair? e-5837) s-5840 #f)
+                                (set-source-properties! e-5837 s-5840))
+                              e-5837)))
+                      (if (if (null? (car w-5839)) (null? (cdr w-5839)) #f)
+                        x-6171
+                        (if (if (vector? x-6171)
+                              (if (= (vector-length x-6171) 4)
+                                (eq? (vector-ref x-6171 0) 'syntax-object)
                                 #f)
                               #f)
-                          (let ((expression-6394 (vector-ref x-6362 1))
-                                (wrap-6395
-                                  (let ((w2-6403 (vector-ref x-6362 2)))
-                                    (let ((m1-6404 (car w-6030))
-                                          (s1-6405 (cdr w-6030)))
-                                      (if (null? m1-6404)
-                                        (if (null? s1-6405)
-                                          w2-6403
-                                          (cons (car w2-6403)
-                                                (let ((m2-6420 (cdr w2-6403)))
-                                                  (if (null? m2-6420)
-                                                    s1-6405
+                          (let ((expression-6203 (vector-ref x-6171 1))
+                                (wrap-6204
+                                  (let ((w2-6212 (vector-ref x-6171 2)))
+                                    (let ((m1-6213 (car w-5839))
+                                          (s1-6214 (cdr w-5839)))
+                                      (if (null? m1-6213)
+                                        (if (null? s1-6214)
+                                          w2-6212
+                                          (cons (car w2-6212)
+                                                (let ((m2-6229 (cdr w2-6212)))
+                                                  (if (null? m2-6229)
+                                                    s1-6214
                                                     (append
-                                                      s1-6405
-                                                      m2-6420)))))
-                                        (cons (let ((m2-6428 (car w2-6403)))
-                                                (if (null? m2-6428)
-                                                  m1-6404
-                                                  (append m1-6404 m2-6428)))
-                                              (let ((m2-6436 (cdr w2-6403)))
-                                                (if (null? m2-6436)
-                                                  s1-6405
+                                                      s1-6214
+                                                      m2-6229)))))
+                                        (cons (let ((m2-6237 (car w2-6212)))
+                                                (if (null? m2-6237)
+                                                  m1-6213
+                                                  (append m1-6213 m2-6237)))
+                                              (let ((m2-6245 (cdr w2-6212)))
+                                                (if (null? m2-6245)
+                                                  s1-6214
                                                   (append
-                                                    s1-6405
-                                                    m2-6436))))))))
-                                (module-6396 (vector-ref x-6362 3)))
+                                                    s1-6214
+                                                    m2-6245))))))))
+                                (module-6205 (vector-ref x-6171 3)))
                             (vector
                               'syntax-object
-                              expression-6394
-                              wrap-6395
-                              module-6396))
-                          (if (null? x-6362)
-                            x-6362
+                              expression-6203
+                              wrap-6204
+                              module-6205))
+                          (if (null? x-6171)
+                            x-6171
                             (vector
                               'syntax-object
-                              x-6362
-                              w-6030
-                              mod-6032)))))))
-              (let ((tmp-6034 e-6033))
-                (let ((tmp-6035 ($sc-dispatch tmp-6034 '(_ any))))
-                  (if tmp-6035
+                              x-6171
+                              w-5839
+                              mod-5841)))))))
+              (let ((tmp-5843 e-5842))
+                (let ((tmp-5844 ($sc-dispatch tmp-5843 '(_ any))))
+                  (if tmp-5844
                     (@apply
-                      (lambda (x-6083)
+                      (lambda (x-5892)
                         (call-with-values
                           (lambda ()
-                            (gen-syntax-6020
-                              e-6033
-                              x-6083
-                              r-6029
+                            (gen-syntax-5829
+                              e-5842
+                              x-5892
+                              r-5838
                               '()
-                              ellipsis?-4594
-                              mod-6032))
-                          (lambda (e-6160 maps-6161) (regen-6027 e-6160))))
-                      tmp-6035)
+                              ellipsis?-4390
+                              mod-5841))
+                          (lambda (e-5969 maps-5970) (regen-5836 e-5969))))
+                      tmp-5844)
                     (syntax-violation
                       'syntax
                       "bad `syntax' form"
-                      e-6033))))))))
-      (global-extend-4548
+                      e-5842))))))))
+      (global-extend-4344
         'core
         'lambda
-        (lambda (e-6974 r-6975 w-6976 s-6977 mod-6978)
-          (let ((tmp-6980
-                  ($sc-dispatch e-6974 '(_ any any . each-any))))
-            (if tmp-6980
+        (lambda (e-6785 r-6786 w-6787 s-6788 mod-6789)
+          (let ((tmp-6791
+                  ($sc-dispatch e-6785 '(_ any any . each-any))))
+            (if tmp-6791
               (@apply
-                (lambda (args-6984 e1-6985 e2-6986)
+                (lambda (args-6795 e1-6796 e2-6797)
                   (call-with-values
-                    (lambda () (lambda-formals-4595 args-6984))
-                    (lambda (req-6989 opt-6990 rest-6991 kw-6992)
+                    (lambda () (lambda-formals-4391 args-6795))
+                    (lambda (req-6800 opt-6801 rest-6802 kw-6803)
                       (letrec*
-                        ((lp-6993
-                           (lambda (body-6996 meta-6997)
-                             (let ((tmp-6999
+                        ((lp-6804
+                           (lambda (body-6807 meta-6808)
+                             (let ((tmp-6810
                                      ($sc-dispatch
-                                       body-6996
+                                       body-6807
                                        '(any any . each-any))))
-                               (if (if tmp-6999
+                               (if (if tmp-6810
                                      (@apply
-                                       (lambda (docstring-7003 e1-7004 e2-7005)
+                                       (lambda (docstring-6814 e1-6815 e2-6816)
                                          (string?
-                                           (syntax->datum docstring-7003)))
-                                       tmp-6999)
+                                           (syntax->datum docstring-6814)))
+                                       tmp-6810)
                                      #f)
                                  (@apply
-                                   (lambda (docstring-7006 e1-7007 e2-7008)
-                                     (lp-6993
-                                       (cons e1-7007 e2-7008)
+                                   (lambda (docstring-6817 e1-6818 e2-6819)
+                                     (lp-6804
+                                       (cons e1-6818 e2-6819)
                                        (append
-                                         meta-6997
+                                         meta-6808
                                          (list (cons 'documentation
                                                      (syntax->datum
-                                                       docstring-7006))))))
-                                   tmp-6999)
-                                 (let ((tmp-7009
+                                                       docstring-6817))))))
+                                   tmp-6810)
+                                 (let ((tmp-6820
                                          ($sc-dispatch
-                                           body-6996
+                                           body-6807
                                            '(#(vector #(each (any . any)))
                                              any
                                              .
                                              each-any))))
-                                   (if tmp-7009
+                                   (if tmp-6820
                                      (@apply
-                                       (lambda (k-7013 v-7014 e1-7015 e2-7016)
-                                         (lp-6993
-                                           (cons e1-7015 e2-7016)
+                                       (lambda (k-6824 v-6825 e1-6826 e2-6827)
+                                         (lp-6804
+                                           (cons e1-6826 e2-6827)
                                            (append
-                                             meta-6997
+                                             meta-6808
                                              (syntax->datum
-                                               (map cons k-7013 v-7014)))))
-                                       tmp-7009)
-                                     (expand-simple-lambda-4596
-                                       e-6974
-                                       r-6975
-                                       w-6976
-                                       s-6977
-                                       mod-6978
-                                       req-6989
-                                       rest-6991
-                                       meta-6997
-                                       body-6996))))))))
-                        (lp-6993 (cons e1-6985 e2-6986) '())))))
-                tmp-6980)
-              (syntax-violation 'lambda "bad lambda" e-6974)))))
-      (global-extend-4548
+                                               (map cons k-6824 v-6825)))))
+                                       tmp-6820)
+                                     (expand-simple-lambda-4392
+                                       e-6785
+                                       r-6786
+                                       w-6787
+                                       s-6788
+                                       mod-6789
+                                       req-6800
+                                       rest-6802
+                                       meta-6808
+                                       body-6807))))))))
+                        (lp-6804 (cons e1-6796 e2-6797) '())))))
+                tmp-6791)
+              (syntax-violation 'lambda "bad lambda" e-6785)))))
+      (global-extend-4344
         'core
         'lambda*
-        (lambda (e-7391 r-7392 w-7393 s-7394 mod-7395)
-          (let ((tmp-7397
-                  ($sc-dispatch e-7391 '(_ any any . each-any))))
-            (if tmp-7397
+        (lambda (e-7202 r-7203 w-7204 s-7205 mod-7206)
+          (let ((tmp-7208
+                  ($sc-dispatch e-7202 '(_ any any . each-any))))
+            (if tmp-7208
               (@apply
-                (lambda (args-7401 e1-7402 e2-7403)
+                (lambda (args-7212 e1-7213 e2-7214)
                   (call-with-values
                     (lambda ()
-                      (expand-lambda-case-4598
-                        e-7391
-                        r-7392
-                        w-7393
-                        s-7394
-                        mod-7395
-                        lambda*-formals-4597
-                        (list (cons args-7401 (cons e1-7402 e2-7403)))))
-                    (lambda (meta-7406 lcase-7407)
+                      (expand-lambda-case-4394
+                        e-7202
+                        r-7203
+                        w-7204
+                        s-7205
+                        mod-7206
+                        lambda*-formals-4393
+                        (list (cons args-7212 (cons e1-7213 e2-7214)))))
+                    (lambda (meta-7217 lcase-7218)
                       (make-struct/no-tail
                         (vector-ref %expanded-vtables 14)
-                        s-7394
-                        meta-7406
-                        lcase-7407))))
-                tmp-7397)
-              (syntax-violation 'lambda "bad lambda*" e-7391)))))
-      (global-extend-4548
+                        s-7205
+                        meta-7217
+                        lcase-7218))))
+                tmp-7208)
+              (syntax-violation 'lambda "bad lambda*" e-7202)))))
+      (global-extend-4344
         'core
         'case-lambda
-        (lambda (e-7570 r-7571 w-7572 s-7573 mod-7574)
-          (let ((tmp-7576
+        (lambda (e-7381 r-7382 w-7383 s-7384 mod-7385)
+          (let ((tmp-7387
                   ($sc-dispatch
-                    e-7570
+                    e-7381
                     '(_ (any any . each-any)
                         .
                         #(each (any any . each-any))))))
-            (if tmp-7576
+            (if tmp-7387
               (@apply
-                (lambda (args-7580
-                         e1-7581
-                         e2-7582
-                         args*-7583
-                         e1*-7584
-                         e2*-7585)
+                (lambda (args-7391
+                         e1-7392
+                         e2-7393
+                         args*-7394
+                         e1*-7395
+                         e2*-7396)
                   (call-with-values
                     (lambda ()
-                      (expand-lambda-case-4598
-                        e-7570
-                        r-7571
-                        w-7572
-                        s-7573
-                        mod-7574
-                        lambda-formals-4595
-                        (cons (cons args-7580 (cons e1-7581 e2-7582))
-                              (map (lambda (tmp-3460-7588
-                                            tmp-3459-7589
-                                            tmp-3458-7590)
-                                     (cons tmp-3458-7590
-                                           (cons tmp-3459-7589 tmp-3460-7588)))
-                                   e2*-7585
-                                   e1*-7584
-                                   args*-7583))))
-                    (lambda (meta-7591 lcase-7592)
+                      (expand-lambda-case-4394
+                        e-7381
+                        r-7382
+                        w-7383
+                        s-7384
+                        mod-7385
+                        lambda-formals-4391
+                        (cons (cons args-7391 (cons e1-7392 e2-7393))
+                              (map (lambda (tmp-3329-7399
+                                            tmp-3328-7400
+                                            tmp-3327-7401)
+                                     (cons tmp-3327-7401
+                                           (cons tmp-3328-7400 tmp-3329-7399)))
+                                   e2*-7396
+                                   e1*-7395
+                                   args*-7394))))
+                    (lambda (meta-7402 lcase-7403)
                       (make-struct/no-tail
                         (vector-ref %expanded-vtables 14)
-                        s-7573
-                        meta-7591
-                        lcase-7592))))
-                tmp-7576)
+                        s-7384
+                        meta-7402
+                        lcase-7403))))
+                tmp-7387)
               (syntax-violation
                 'case-lambda
                 "bad case-lambda"
-                e-7570)))))
-      (global-extend-4548
+                e-7381)))))
+      (global-extend-4344
         'core
         'case-lambda*
-        (lambda (e-7761 r-7762 w-7763 s-7764 mod-7765)
-          (let ((tmp-7767
+        (lambda (e-7572 r-7573 w-7574 s-7575 mod-7576)
+          (let ((tmp-7578
                   ($sc-dispatch
-                    e-7761
+                    e-7572
                     '(_ (any any . each-any)
                         .
                         #(each (any any . each-any))))))
-            (if tmp-7767
+            (if tmp-7578
               (@apply
-                (lambda (args-7771
-                         e1-7772
-                         e2-7773
-                         args*-7774
-                         e1*-7775
-                         e2*-7776)
+                (lambda (args-7582
+                         e1-7583
+                         e2-7584
+                         args*-7585
+                         e1*-7586
+                         e2*-7587)
                   (call-with-values
                     (lambda ()
-                      (expand-lambda-case-4598
-                        e-7761
-                        r-7762
-                        w-7763
-                        s-7764
-                        mod-7765
-                        lambda*-formals-4597
-                        (cons (cons args-7771 (cons e1-7772 e2-7773))
-                              (map (lambda (tmp-3495-7779
-                                            tmp-3494-7780
-                                            tmp-3493-7781)
-                                     (cons tmp-3493-7781
-                                           (cons tmp-3494-7780 tmp-3495-7779)))
-                                   e2*-7776
-                                   e1*-7775
-                                   args*-7774))))
-                    (lambda (meta-7782 lcase-7783)
+                      (expand-lambda-case-4394
+                        e-7572
+                        r-7573
+                        w-7574
+                        s-7575
+                        mod-7576
+                        lambda*-formals-4393
+                        (cons (cons args-7582 (cons e1-7583 e2-7584))
+                              (map (lambda (tmp-3364-7590
+                                            tmp-3363-7591
+                                            tmp-3362-7592)
+                                     (cons tmp-3362-7592
+                                           (cons tmp-3363-7591 tmp-3364-7590)))
+                                   e2*-7587
+                                   e1*-7586
+                                   args*-7585))))
+                    (lambda (meta-7593 lcase-7594)
                       (make-struct/no-tail
                         (vector-ref %expanded-vtables 14)
-                        s-7764
-                        meta-7782
-                        lcase-7783))))
-                tmp-7767)
+                        s-7575
+                        meta-7593
+                        lcase-7594))))
+                tmp-7578)
               (syntax-violation
                 'case-lambda
                 "bad case-lambda*"
-                e-7761)))))
-      (global-extend-4548
+                e-7572)))))
+      (global-extend-4344
         'core
         'let
         (letrec*
-          ((expand-let-7991
-             (lambda (e-8201
-                      r-8202
-                      w-8203
-                      s-8204
-                      mod-8205
-                      constructor-8206
-                      ids-8207
-                      vals-8208
-                      exps-8209)
-               (if (not (valid-bound-ids?-4576 ids-8207))
+          ((expand-let-7802
+             (lambda (e-8012
+                      r-8013
+                      w-8014
+                      s-8015
+                      mod-8016
+                      constructor-8017
+                      ids-8018
+                      vals-8019
+                      exps-8020)
+               (if (not (valid-bound-ids?-4372 ids-8018))
                  (syntax-violation
                    'let
                    "duplicate bound variable"
-                   e-8201)
-                 (let ((labels-8294 (gen-labels-4553 ids-8207))
-                       (new-vars-8295 (map gen-var-4600 ids-8207)))
-                   (let ((nw-8296
-                           (make-binding-wrap-4564
-                             ids-8207
-                             labels-8294
-                             w-8203))
-                         (nr-8297
-                           (extend-var-env-4546
-                             labels-8294
-                             new-vars-8295
-                             r-8202)))
-                     (constructor-8206
-                       s-8204
-                       (map syntax->datum ids-8207)
-                       new-vars-8295
-                       (map (lambda (x-8314)
-                              (expand-4586 x-8314 r-8202 w-8203 mod-8205))
-                            vals-8208)
-                       (expand-body-4590
-                         exps-8209
-                         (source-wrap-4580 e-8201 nw-8296 s-8204 mod-8205)
-                         nr-8297
-                         nw-8296
-                         mod-8205))))))))
-          (lambda (e-7992 r-7993 w-7994 s-7995 mod-7996)
-            (let ((tmp-7998
+                   e-8012)
+                 (let ((labels-8105 (gen-labels-4349 ids-8018))
+                       (new-vars-8106 (map gen-var-4396 ids-8018)))
+                   (let ((nw-8107
+                           (make-binding-wrap-4360
+                             ids-8018
+                             labels-8105
+                             w-8014))
+                         (nr-8108
+                           (extend-var-env-4342
+                             labels-8105
+                             new-vars-8106
+                             r-8013)))
+                     (constructor-8017
+                       s-8015
+                       (map syntax->datum ids-8018)
+                       new-vars-8106
+                       (map (lambda (x-8125)
+                              (expand-4382 x-8125 r-8013 w-8014 mod-8016))
+                            vals-8019)
+                       (expand-body-4386
+                         exps-8020
+                         (source-wrap-4376 e-8012 nw-8107 s-8015 mod-8016)
+                         nr-8108
+                         nw-8107
+                         mod-8016))))))))
+          (lambda (e-7803 r-7804 w-7805 s-7806 mod-7807)
+            (let ((tmp-7809
                     ($sc-dispatch
-                      e-7992
+                      e-7803
                       '(_ #(each (any any)) any . each-any))))
-              (if (if tmp-7998
+              (if (if tmp-7809
                     (@apply
-                      (lambda (id-8002 val-8003 e1-8004 e2-8005)
-                        (and-map id?-4550 id-8002))
-                      tmp-7998)
+                      (lambda (id-7813 val-7814 e1-7815 e2-7816)
+                        (and-map id?-4346 id-7813))
+                      tmp-7809)
                     #f)
                 (@apply
-                  (lambda (id-8021 val-8022 e1-8023 e2-8024)
-                    (expand-let-7991
-                      e-7992
-                      r-7993
-                      w-7994
-                      s-7995
-                      mod-7996
-                      (lambda (src-8028
-                               ids-8029
-                               vars-8030
-                               val-exps-8031
-                               body-exp-8032)
+                  (lambda (id-7832 val-7833 e1-7834 e2-7835)
+                    (expand-let-7802
+                      e-7803
+                      r-7804
+                      w-7805
+                      s-7806
+                      mod-7807
+                      (lambda (src-7839
+                               ids-7840
+                               vars-7841
+                               val-exps-7842
+                               body-exp-7843)
                         (begin
                           (for-each
-                            maybe-name-value!-4515
-                            ids-8029
-                            val-exps-8031)
-                          (if (null? vars-8030)
-                            body-exp-8032
+                            maybe-name-value!-4311
+                            ids-7840
+                            val-exps-7842)
+                          (if (null? vars-7841)
+                            body-exp-7843
                             (make-struct/no-tail
                               (vector-ref %expanded-vtables 16)
-                              src-8028
-                              ids-8029
-                              vars-8030
-                              val-exps-8031
-                              body-exp-8032))))
-                      id-8021
-                      val-8022
-                      (cons e1-8023 e2-8024)))
-                  tmp-7998)
-                (let ((tmp-8039
+                              src-7839
+                              ids-7840
+                              vars-7841
+                              val-exps-7842
+                              body-exp-7843))))
+                      id-7832
+                      val-7833
+                      (cons e1-7834 e2-7835)))
+                  tmp-7809)
+                (let ((tmp-7850
                         ($sc-dispatch
-                          e-7992
+                          e-7803
                           '(_ any #(each (any any)) any . each-any))))
-                  (if (if tmp-8039
+                  (if (if tmp-7850
                         (@apply
-                          (lambda (f-8043 id-8044 val-8045 e1-8046 e2-8047)
-                            (if (if (symbol? f-8043)
+                          (lambda (f-7854 id-7855 val-7856 e1-7857 e2-7858)
+                            (if (if (symbol? f-7854)
                                   #t
-                                  (if (if (vector? f-8043)
-                                        (if (= (vector-length f-8043) 4)
-                                          (eq? (vector-ref f-8043 0)
+                                  (if (if (vector? f-7854)
+                                        (if (= (vector-length f-7854) 4)
+                                          (eq? (vector-ref f-7854 0)
                                                'syntax-object)
                                           #f)
                                         #f)
-                                    (symbol? (vector-ref f-8043 1))
+                                    (symbol? (vector-ref f-7854 1))
                                     #f))
-                              (and-map id?-4550 id-8044)
+                              (and-map id?-4346 id-7855)
                               #f))
-                          tmp-8039)
+                          tmp-7850)
                         #f)
                     (@apply
-                      (lambda (f-8089 id-8090 val-8091 e1-8092 e2-8093)
-                        (expand-let-7991
-                          e-7992
-                          r-7993
-                          w-7994
-                          s-7995
-                          mod-7996
-                          build-named-let-4534
-                          (cons f-8089 id-8090)
-                          val-8091
-                          (cons e1-8092 e2-8093)))
-                      tmp-8039)
+                      (lambda (f-7900 id-7901 val-7902 e1-7903 e2-7904)
+                        (expand-let-7802
+                          e-7803
+                          r-7804
+                          w-7805
+                          s-7806
+                          mod-7807
+                          build-named-let-4330
+                          (cons f-7900 id-7901)
+                          val-7902
+                          (cons e1-7903 e2-7904)))
+                      tmp-7850)
                     (syntax-violation
                       'let
                       "bad let"
-                      (let ((x-8106
+                      (let ((x-7917
                               (begin
-                                (if (if (pair? e-7992) s-7995 #f)
-                                  (set-source-properties! e-7992 s-7995))
-                                e-7992)))
-                        (if (if (null? (car w-7994)) (null? (cdr w-7994)) #f)
-                          x-8106
-                          (if (if (vector? x-8106)
-                                (if (= (vector-length x-8106) 4)
-                                  (eq? (vector-ref x-8106 0) 'syntax-object)
+                                (if (if (pair? e-7803) s-7806 #f)
+                                  (set-source-properties! e-7803 s-7806))
+                                e-7803)))
+                        (if (if (null? (car w-7805)) (null? (cdr w-7805)) #f)
+                          x-7917
+                          (if (if (vector? x-7917)
+                                (if (= (vector-length x-7917) 4)
+                                  (eq? (vector-ref x-7917 0) 'syntax-object)
                                   #f)
                                 #f)
-                            (let ((expression-8138 (vector-ref x-8106 1))
-                                  (wrap-8139
-                                    (let ((w2-8147 (vector-ref x-8106 2)))
-                                      (let ((m1-8148 (car w-7994))
-                                            (s1-8149 (cdr w-7994)))
-                                        (if (null? m1-8148)
-                                          (if (null? s1-8149)
-                                            w2-8147
-                                            (cons (car w2-8147)
-                                                  (let ((m2-8164
-                                                          (cdr w2-8147)))
-                                                    (if (null? m2-8164)
-                                                      s1-8149
+                            (let ((expression-7949 (vector-ref x-7917 1))
+                                  (wrap-7950
+                                    (let ((w2-7958 (vector-ref x-7917 2)))
+                                      (let ((m1-7959 (car w-7805))
+                                            (s1-7960 (cdr w-7805)))
+                                        (if (null? m1-7959)
+                                          (if (null? s1-7960)
+                                            w2-7958
+                                            (cons (car w2-7958)
+                                                  (let ((m2-7975
+                                                          (cdr w2-7958)))
+                                                    (if (null? m2-7975)
+                                                      s1-7960
                                                       (append
-                                                        s1-8149
-                                                        m2-8164)))))
-                                          (cons (let ((m2-8172 (car w2-8147)))
-                                                  (if (null? m2-8172)
-                                                    m1-8148
-                                                    (append m1-8148 m2-8172)))
-                                                (let ((m2-8180 (cdr w2-8147)))
-                                                  (if (null? m2-8180)
-                                                    s1-8149
+                                                        s1-7960
+                                                        m2-7975)))))
+                                          (cons (let ((m2-7983 (car w2-7958)))
+                                                  (if (null? m2-7983)
+                                                    m1-7959
+                                                    (append m1-7959 m2-7983)))
+                                                (let ((m2-7991 (cdr w2-7958)))
+                                                  (if (null? m2-7991)
+                                                    s1-7960
                                                     (append
-                                                      s1-8149
-                                                      m2-8180))))))))
-                                  (module-8140 (vector-ref x-8106 3)))
+                                                      s1-7960
+                                                      m2-7991))))))))
+                                  (module-7951 (vector-ref x-7917 3)))
                               (vector
                                 'syntax-object
-                                expression-8138
-                                wrap-8139
-                                module-8140))
-                            (if (null? x-8106)
-                              x-8106
+                                expression-7949
+                                wrap-7950
+                                module-7951))
+                            (if (null? x-7917)
+                              x-7917
                               (vector
                                 'syntax-object
-                                x-8106
-                                w-7994
-                                mod-7996)))))))))))))
-      (global-extend-4548
+                                x-7917
+                                w-7805
+                                mod-7807)))))))))))))
+      (global-extend-4344
         'core
         'letrec
-        (lambda (e-8744 r-8745 w-8746 s-8747 mod-8748)
-          (let ((tmp-8750
+        (lambda (e-8555 r-8556 w-8557 s-8558 mod-8559)
+          (let ((tmp-8561
                   ($sc-dispatch
-                    e-8744
+                    e-8555
                     '(_ #(each (any any)) any . each-any))))
-            (if (if tmp-8750
+            (if (if tmp-8561
                   (@apply
-                    (lambda (id-8754 val-8755 e1-8756 e2-8757)
-                      (and-map id?-4550 id-8754))
-                    tmp-8750)
+                    (lambda (id-8565 val-8566 e1-8567 e2-8568)
+                      (and-map id?-4346 id-8565))
+                    tmp-8561)
                   #f)
               (@apply
-                (lambda (id-8773 val-8774 e1-8775 e2-8776)
-                  (if (not (valid-bound-ids?-4576 id-8773))
+                (lambda (id-8584 val-8585 e1-8586 e2-8587)
+                  (if (not (valid-bound-ids?-4372 id-8584))
                     (syntax-violation
                       'letrec
                       "duplicate bound variable"
-                      e-8744)
-                    (let ((labels-8873 (gen-labels-4553 id-8773))
-                          (new-vars-8874 (map gen-var-4600 id-8773)))
-                      (let ((w-8875
-                              (make-binding-wrap-4564
-                                id-8773
-                                labels-8873
-                                w-8746))
-                            (r-8876
-                              (extend-var-env-4546
-                                labels-8873
-                                new-vars-8874
-                                r-8745)))
-                        (build-letrec-4535
-                          s-8747
+                      e-8555)
+                    (let ((labels-8684 (gen-labels-4349 id-8584))
+                          (new-vars-8685 (map gen-var-4396 id-8584)))
+                      (let ((w-8686
+                              (make-binding-wrap-4360
+                                id-8584
+                                labels-8684
+                                w-8557))
+                            (r-8687
+                              (extend-var-env-4342
+                                labels-8684
+                                new-vars-8685
+                                r-8556)))
+                        (build-letrec-4331
+                          s-8558
                           #f
-                          (map syntax->datum id-8773)
-                          new-vars-8874
-                          (map (lambda (x-8953)
-                                 (expand-4586 x-8953 r-8876 w-8875 mod-8748))
-                               val-8774)
-                          (expand-body-4590
-                            (cons e1-8775 e2-8776)
-                            (let ((x-9015
+                          (map syntax->datum id-8584)
+                          new-vars-8685
+                          (map (lambda (x-8764)
+                                 (expand-4382 x-8764 r-8687 w-8686 mod-8559))
+                               val-8585)
+                          (expand-body-4386
+                            (cons e1-8586 e2-8587)
+                            (let ((x-8826
                                     (begin
-                                      (if (if (pair? e-8744) s-8747 #f)
-                                        (set-source-properties! e-8744 s-8747))
-                                      e-8744)))
-                              (if (if (null? (car w-8875))
-                                    (null? (cdr w-8875))
+                                      (if (if (pair? e-8555) s-8558 #f)
+                                        (set-source-properties! e-8555 s-8558))
+                                      e-8555)))
+                              (if (if (null? (car w-8686))
+                                    (null? (cdr w-8686))
                                     #f)
-                                x-9015
-                                (if (if (vector? x-9015)
-                                      (if (= (vector-length x-9015) 4)
-                                        (eq? (vector-ref x-9015 0)
+                                x-8826
+                                (if (if (vector? x-8826)
+                                      (if (= (vector-length x-8826) 4)
+                                        (eq? (vector-ref x-8826 0)
                                              'syntax-object)
                                         #f)
                                       #f)
-                                  (let ((expression-9047 (vector-ref x-9015 1))
-                                        (wrap-9048
-                                          (let ((w2-9056
-                                                  (vector-ref x-9015 2)))
-                                            (let ((m1-9057 (car w-8875))
-                                                  (s1-9058 (cdr w-8875)))
-                                              (if (null? m1-9057)
-                                                (if (null? s1-9058)
-                                                  w2-9056
-                                                  (cons (car w2-9056)
-                                                        (let ((m2-9073
-                                                                (cdr w2-9056)))
-                                                          (if (null? m2-9073)
-                                                            s1-9058
+                                  (let ((expression-8858 (vector-ref x-8826 1))
+                                        (wrap-8859
+                                          (let ((w2-8867
+                                                  (vector-ref x-8826 2)))
+                                            (let ((m1-8868 (car w-8686))
+                                                  (s1-8869 (cdr w-8686)))
+                                              (if (null? m1-8868)
+                                                (if (null? s1-8869)
+                                                  w2-8867
+                                                  (cons (car w2-8867)
+                                                        (let ((m2-8884
+                                                                (cdr w2-8867)))
+                                                          (if (null? m2-8884)
+                                                            s1-8869
                                                             (append
-                                                              s1-9058
-                                                              m2-9073)))))
-                                                (cons (let ((m2-9081
-                                                              (car w2-9056)))
-                                                        (if (null? m2-9081)
-                                                          m1-9057
+                                                              s1-8869
+                                                              m2-8884)))))
+                                                (cons (let ((m2-8892
+                                                              (car w2-8867)))
+                                                        (if (null? m2-8892)
+                                                          m1-8868
                                                           (append
-                                                            m1-9057
-                                                            m2-9081)))
-                                                      (let ((m2-9089
-                                                              (cdr w2-9056)))
-                                                        (if (null? m2-9089)
-                                                          s1-9058
+                                                            m1-8868
+                                                            m2-8892)))
+                                                      (let ((m2-8900
+                                                              (cdr w2-8867)))
+                                                        (if (null? m2-8900)
+                                                          s1-8869
                                                           (append
-                                                            s1-9058
-                                                            m2-9089))))))))
-                                        (module-9049 (vector-ref x-9015 3)))
+                                                            s1-8869
+                                                            m2-8900))))))))
+                                        (module-8860 (vector-ref x-8826 3)))
                                     (vector
                                       'syntax-object
-                                      expression-9047
-                                      wrap-9048
-                                      module-9049))
-                                  (if (null? x-9015)
-                                    x-9015
+                                      expression-8858
+                                      wrap-8859
+                                      module-8860))
+                                  (if (null? x-8826)
+                                    x-8826
                                     (vector
                                       'syntax-object
-                                      x-9015
-                                      w-8875
-                                      mod-8748)))))
-                            r-8876
-                            w-8875
-                            mod-8748))))))
-                tmp-8750)
+                                      x-8826
+                                      w-8686
+                                      mod-8559)))))
+                            r-8687
+                            w-8686
+                            mod-8559))))))
+                tmp-8561)
               (syntax-violation
                 'letrec
                 "bad letrec"
-                (let ((x-9300
+                (let ((x-9111
                         (begin
-                          (if (if (pair? e-8744) s-8747 #f)
-                            (set-source-properties! e-8744 s-8747))
-                          e-8744)))
-                  (if (if (null? (car w-8746)) (null? (cdr w-8746)) #f)
-                    x-9300
-                    (if (if (vector? x-9300)
-                          (if (= (vector-length x-9300) 4)
-                            (eq? (vector-ref x-9300 0) 'syntax-object)
+                          (if (if (pair? e-8555) s-8558 #f)
+                            (set-source-properties! e-8555 s-8558))
+                          e-8555)))
+                  (if (if (null? (car w-8557)) (null? (cdr w-8557)) #f)
+                    x-9111
+                    (if (if (vector? x-9111)
+                          (if (= (vector-length x-9111) 4)
+                            (eq? (vector-ref x-9111 0) 'syntax-object)
                             #f)
                           #f)
-                      (let ((expression-9332 (vector-ref x-9300 1))
-                            (wrap-9333
-                              (let ((w2-9341 (vector-ref x-9300 2)))
-                                (let ((m1-9342 (car w-8746))
-                                      (s1-9343 (cdr w-8746)))
-                                  (if (null? m1-9342)
-                                    (if (null? s1-9343)
-                                      w2-9341
-                                      (cons (car w2-9341)
-                                            (let ((m2-9358 (cdr w2-9341)))
-                                              (if (null? m2-9358)
-                                                s1-9343
-                                                (append s1-9343 m2-9358)))))
-                                    (cons (let ((m2-9366 (car w2-9341)))
-                                            (if (null? m2-9366)
-                                              m1-9342
-                                              (append m1-9342 m2-9366)))
-                                          (let ((m2-9374 (cdr w2-9341)))
-                                            (if (null? m2-9374)
-                                              s1-9343
-                                              (append s1-9343 m2-9374))))))))
-                            (module-9334 (vector-ref x-9300 3)))
+                      (let ((expression-9143 (vector-ref x-9111 1))
+                            (wrap-9144
+                              (let ((w2-9152 (vector-ref x-9111 2)))
+                                (let ((m1-9153 (car w-8557))
+                                      (s1-9154 (cdr w-8557)))
+                                  (if (null? m1-9153)
+                                    (if (null? s1-9154)
+                                      w2-9152
+                                      (cons (car w2-9152)
+                                            (let ((m2-9169 (cdr w2-9152)))
+                                              (if (null? m2-9169)
+                                                s1-9154
+                                                (append s1-9154 m2-9169)))))
+                                    (cons (let ((m2-9177 (car w2-9152)))
+                                            (if (null? m2-9177)
+                                              m1-9153
+                                              (append m1-9153 m2-9177)))
+                                          (let ((m2-9185 (cdr w2-9152)))
+                                            (if (null? m2-9185)
+                                              s1-9154
+                                              (append s1-9154 m2-9185))))))))
+                            (module-9145 (vector-ref x-9111 3)))
                         (vector
                           'syntax-object
-                          expression-9332
-                          wrap-9333
-                          module-9334))
-                      (if (null? x-9300)
-                        x-9300
-                        (vector 'syntax-object x-9300 w-8746 mod-8748))))))))))
-      (global-extend-4548
+                          expression-9143
+                          wrap-9144
+                          module-9145))
+                      (if (null? x-9111)
+                        x-9111
+                        (vector 'syntax-object x-9111 w-8557 mod-8559))))))))))
+      (global-extend-4344
         'core
         'letrec*
-        (lambda (e-9525 r-9526 w-9527 s-9528 mod-9529)
-          (let ((tmp-9531
+        (lambda (e-9336 r-9337 w-9338 s-9339 mod-9340)
+          (let ((tmp-9342
                   ($sc-dispatch
-                    e-9525
+                    e-9336
                     '(_ #(each (any any)) any . each-any))))
-            (if (if tmp-9531
+            (if (if tmp-9342
                   (@apply
-                    (lambda (id-9535 val-9536 e1-9537 e2-9538)
-                      (and-map id?-4550 id-9535))
-                    tmp-9531)
+                    (lambda (id-9346 val-9347 e1-9348 e2-9349)
+                      (and-map id?-4346 id-9346))
+                    tmp-9342)
                   #f)
               (@apply
-                (lambda (id-9554 val-9555 e1-9556 e2-9557)
-                  (if (not (valid-bound-ids?-4576 id-9554))
+                (lambda (id-9365 val-9366 e1-9367 e2-9368)
+                  (if (not (valid-bound-ids?-4372 id-9365))
                     (syntax-violation
                       'letrec*
                       "duplicate bound variable"
-                      e-9525)
-                    (let ((labels-9654 (gen-labels-4553 id-9554))
-                          (new-vars-9655 (map gen-var-4600 id-9554)))
-                      (let ((w-9656
-                              (make-binding-wrap-4564
-                                id-9554
-                                labels-9654
-                                w-9527))
-                            (r-9657
-                              (extend-var-env-4546
-                                labels-9654
-                                new-vars-9655
-                                r-9526)))
-                        (build-letrec-4535
-                          s-9528
+                      e-9336)
+                    (let ((labels-9465 (gen-labels-4349 id-9365))
+                          (new-vars-9466 (map gen-var-4396 id-9365)))
+                      (let ((w-9467
+                              (make-binding-wrap-4360
+                                id-9365
+                                labels-9465
+                                w-9338))
+                            (r-9468
+                              (extend-var-env-4342
+                                labels-9465
+                                new-vars-9466
+                                r-9337)))
+                        (build-letrec-4331
+                          s-9339
                           #t
-                          (map syntax->datum id-9554)
-                          new-vars-9655
-                          (map (lambda (x-9734)
-                                 (expand-4586 x-9734 r-9657 w-9656 mod-9529))
-                               val-9555)
-                          (expand-body-4590
-                            (cons e1-9556 e2-9557)
-                            (let ((x-9796
+                          (map syntax->datum id-9365)
+                          new-vars-9466
+                          (map (lambda (x-9545)
+                                 (expand-4382 x-9545 r-9468 w-9467 mod-9340))
+                               val-9366)
+                          (expand-body-4386
+                            (cons e1-9367 e2-9368)
+                            (let ((x-9607
                                     (begin
-                                      (if (if (pair? e-9525) s-9528 #f)
-                                        (set-source-properties! e-9525 s-9528))
-                                      e-9525)))
-                              (if (if (null? (car w-9656))
-                                    (null? (cdr w-9656))
+                                      (if (if (pair? e-9336) s-9339 #f)
+                                        (set-source-properties! e-9336 s-9339))
+                                      e-9336)))
+                              (if (if (null? (car w-9467))
+                                    (null? (cdr w-9467))
                                     #f)
-                                x-9796
-                                (if (if (vector? x-9796)
-                                      (if (= (vector-length x-9796) 4)
-                                        (eq? (vector-ref x-9796 0)
+                                x-9607
+                                (if (if (vector? x-9607)
+                                      (if (= (vector-length x-9607) 4)
+                                        (eq? (vector-ref x-9607 0)
                                              'syntax-object)
                                         #f)
                                       #f)
-                                  (let ((expression-9828 (vector-ref x-9796 1))
-                                        (wrap-9829
-                                          (let ((w2-9837
-                                                  (vector-ref x-9796 2)))
-                                            (let ((m1-9838 (car w-9656))
-                                                  (s1-9839 (cdr w-9656)))
-                                              (if (null? m1-9838)
-                                                (if (null? s1-9839)
-                                                  w2-9837
-                                                  (cons (car w2-9837)
-                                                        (let ((m2-9854
-                                                                (cdr w2-9837)))
-                                                          (if (null? m2-9854)
-                                                            s1-9839
+                                  (let ((expression-9639 (vector-ref x-9607 1))
+                                        (wrap-9640
+                                          (let ((w2-9648
+                                                  (vector-ref x-9607 2)))
+                                            (let ((m1-9649 (car w-9467))
+                                                  (s1-9650 (cdr w-9467)))
+                                              (if (null? m1-9649)
+                                                (if (null? s1-9650)
+                                                  w2-9648
+                                                  (cons (car w2-9648)
+                                                        (let ((m2-9665
+                                                                (cdr w2-9648)))
+                                                          (if (null? m2-9665)
+                                                            s1-9650
                                                             (append
-                                                              s1-9839
-                                                              m2-9854)))))
-                                                (cons (let ((m2-9862
-                                                              (car w2-9837)))
-                                                        (if (null? m2-9862)
-                                                          m1-9838
+                                                              s1-9650
+                                                              m2-9665)))))
+                                                (cons (let ((m2-9673
+                                                              (car w2-9648)))
+                                                        (if (null? m2-9673)
+                                                          m1-9649
                                                           (append
-                                                            m1-9838
-                                                            m2-9862)))
-                                                      (let ((m2-9870
-                                                              (cdr w2-9837)))
-                                                        (if (null? m2-9870)
-                                                          s1-9839
+                                                            m1-9649
+                                                            m2-9673)))
+                                                      (let ((m2-9681
+                                                              (cdr w2-9648)))
+                                                        (if (null? m2-9681)
+                                                          s1-9650
                                                           (append
-                                                            s1-9839
-                                                            m2-9870))))))))
-                                        (module-9830 (vector-ref x-9796 3)))
+                                                            s1-9650
+                                                            m2-9681))))))))
+                                        (module-9641 (vector-ref x-9607 3)))
                                     (vector
                                       'syntax-object
-                                      expression-9828
-                                      wrap-9829
-                                      module-9830))
-                                  (if (null? x-9796)
-                                    x-9796
+                                      expression-9639
+                                      wrap-9640
+                                      module-9641))
+                                  (if (null? x-9607)
+                                    x-9607
                                     (vector
                                       'syntax-object
-                                      x-9796
-                                      w-9656
-                                      mod-9529)))))
-                            r-9657
-                            w-9656
-                            mod-9529))))))
-                tmp-9531)
+                                      x-9607
+                                      w-9467
+                                      mod-9340)))))
+                            r-9468
+                            w-9467
+                            mod-9340))))))
+                tmp-9342)
               (syntax-violation
                 'letrec*
                 "bad letrec*"
-                (let ((x-10081
+                (let ((x-9892
                         (begin
-                          (if (if (pair? e-9525) s-9528 #f)
-                            (set-source-properties! e-9525 s-9528))
-                          e-9525)))
-                  (if (if (null? (car w-9527)) (null? (cdr w-9527)) #f)
-                    x-10081
-                    (if (if (vector? x-10081)
-                          (if (= (vector-length x-10081) 4)
-                            (eq? (vector-ref x-10081 0) 'syntax-object)
+                          (if (if (pair? e-9336) s-9339 #f)
+                            (set-source-properties! e-9336 s-9339))
+                          e-9336)))
+                  (if (if (null? (car w-9338)) (null? (cdr w-9338)) #f)
+                    x-9892
+                    (if (if (vector? x-9892)
+                          (if (= (vector-length x-9892) 4)
+                            (eq? (vector-ref x-9892 0) 'syntax-object)
                             #f)
                           #f)
-                      (let ((expression-10113 (vector-ref x-10081 1))
-                            (wrap-10114
-                              (let ((w2-10122 (vector-ref x-10081 2)))
-                                (let ((m1-10123 (car w-9527))
-                                      (s1-10124 (cdr w-9527)))
-                                  (if (null? m1-10123)
-                                    (if (null? s1-10124)
-                                      w2-10122
-                                      (cons (car w2-10122)
-                                            (let ((m2-10139 (cdr w2-10122)))
-                                              (if (null? m2-10139)
-                                                s1-10124
-                                                (append s1-10124 m2-10139)))))
-                                    (cons (let ((m2-10147 (car w2-10122)))
-                                            (if (null? m2-10147)
-                                              m1-10123
-                                              (append m1-10123 m2-10147)))
-                                          (let ((m2-10155 (cdr w2-10122)))
-                                            (if (null? m2-10155)
-                                              s1-10124
-                                              (append s1-10124 m2-10155))))))))
-                            (module-10115 (vector-ref x-10081 3)))
-                        (vector
-                          'syntax-object
-                          expression-10113
-                          wrap-10114
-                          module-10115))
-                      (if (null? x-10081)
-                        x-10081
+                      (let ((expression-9924 (vector-ref x-9892 1))
+                            (wrap-9925
+                              (let ((w2-9933 (vector-ref x-9892 2)))
+                                (let ((m1-9934 (car w-9338))
+                                      (s1-9935 (cdr w-9338)))
+                                  (if (null? m1-9934)
+                                    (if (null? s1-9935)
+                                      w2-9933
+                                      (cons (car w2-9933)
+                                            (let ((m2-9950 (cdr w2-9933)))
+                                              (if (null? m2-9950)
+                                                s1-9935
+                                                (append s1-9935 m2-9950)))))
+                                    (cons (let ((m2-9958 (car w2-9933)))
+                                            (if (null? m2-9958)
+                                              m1-9934
+                                              (append m1-9934 m2-9958)))
+                                          (let ((m2-9966 (cdr w2-9933)))
+                                            (if (null? m2-9966)
+                                              s1-9935
+                                              (append s1-9935 m2-9966))))))))
+                            (module-9926 (vector-ref x-9892 3)))
                         (vector
                           'syntax-object
-                          x-10081
-                          w-9527
-                          mod-9529))))))))))
-      (global-extend-4548
+                          expression-9924
+                          wrap-9925
+                          module-9926))
+                      (if (null? x-9892)
+                        x-9892
+                        (vector 'syntax-object x-9892 w-9338 mod-9340))))))))))
+      (global-extend-4344
         'core
         'set!
-        (lambda (e-10314 r-10315 w-10316 s-10317 mod-10318)
-          (let ((tmp-10320 ($sc-dispatch e-10314 '(_ any any))))
-            (if (if tmp-10320
+        (lambda (e-10128 r-10129 w-10130 s-10131 mod-10132)
+          (let ((tmp-10134 ($sc-dispatch e-10128 '(_ any any))))
+            (if (if tmp-10134
                   (@apply
-                    (lambda (id-10324 val-10325)
-                      (if (symbol? id-10324)
+                    (lambda (id-10138 val-10139)
+                      (if (symbol? id-10138)
                         #t
-                        (if (if (vector? id-10324)
-                              (if (= (vector-length id-10324) 4)
-                                (eq? (vector-ref id-10324 0) 'syntax-object)
+                        (if (if (vector? id-10138)
+                              (if (= (vector-length id-10138) 4)
+                                (eq? (vector-ref id-10138 0) 'syntax-object)
                                 #f)
                               #f)
-                          (symbol? (vector-ref id-10324 1))
+                          (symbol? (vector-ref id-10138 1))
                           #f)))
-                    tmp-10320)
+                    tmp-10134)
                   #f)
               (@apply
-                (lambda (id-10352 val-10353)
+                (lambda (id-10166 val-10167)
                   (call-with-values
                     (lambda ()
-                      (resolve-identifier-4571
-                        id-10352
-                        w-10316
-                        r-10315
-                        mod-10318
+                      (resolve-identifier-4367
+                        id-10166
+                        w-10130
+                        r-10129
+                        mod-10132
                         #t))
-                    (lambda (type-10356 value-10357 id-mod-10358)
-                      (if (eqv? type-10356 'lexical)
-                        (build-lexical-assignment-4521
-                          s-10317
-                          (syntax->datum id-10352)
-                          value-10357
-                          (expand-4586 val-10353 r-10315 w-10316 mod-10318))
-                        (if (eqv? type-10356 'global)
-                          (build-global-assignment-4524
-                            s-10317
-                            value-10357
-                            (expand-4586 val-10353 r-10315 w-10316 mod-10318)
-                            id-mod-10358)
-                          (if (eqv? type-10356 'macro)
+                    (lambda (type-10170 value-10171 id-mod-10172)
+                      (if (eqv? type-10170 'lexical)
+                        (build-lexical-assignment-4317
+                          s-10131
+                          (syntax->datum id-10166)
+                          value-10171
+                          (expand-4382 val-10167 r-10129 w-10130 mod-10132))
+                        (if (eqv? type-10170 'global)
+                          (build-global-assignment-4320
+                            s-10131
+                            value-10171
+                            (expand-4382 val-10167 r-10129 w-10130 mod-10132)
+                            id-mod-10172)
+                          (if (eqv? type-10170 'macro)
                             (if (procedure-property
-                                  value-10357
+                                  value-10171
                                   'variable-transformer)
-                              (expand-4586
-                                (expand-macro-4589
-                                  value-10357
-                                  e-10314
-                                  r-10315
-                                  w-10316
-                                  s-10317
+                              (expand-4382
+                                (expand-macro-4385
+                                  value-10171
+                                  e-10128
+                                  r-10129
+                                  w-10130
+                                  s-10131
                                   #f
-                                  mod-10318)
-                                r-10315
+                                  mod-10132)
+                                r-10129
                                 '(())
-                                mod-10318)
+                                mod-10132)
                               (syntax-violation
                                 'set!
                                 "not a variable transformer"
-                                (if (if (null? (car w-10316))
-                                      (null? (cdr w-10316))
+                                (if (if (null? (car w-10130))
+                                      (null? (cdr w-10130))
                                       #f)
-                                  e-10314
-                                  (if (if (vector? e-10314)
-                                        (if (= (vector-length e-10314) 4)
-                                          (eq? (vector-ref e-10314 0)
+                                  e-10128
+                                  (if (if (vector? e-10128)
+                                        (if (= (vector-length e-10128) 4)
+                                          (eq? (vector-ref e-10128 0)
                                                'syntax-object)
                                           #f)
                                         #f)
-                                    (let ((expression-10798
-                                            (vector-ref e-10314 1))
-                                          (wrap-10799
-                                            (let ((w2-10809
-                                                    (vector-ref e-10314 2)))
-                                              (let ((m1-10810 (car w-10316))
-                                                    (s1-10811 (cdr w-10316)))
-                                                (if (null? m1-10810)
-                                                  (if (null? s1-10811)
-                                                    w2-10809
-                                                    (cons (car w2-10809)
-                                                          (let ((m2-10828
-                                                                  (cdr 
w2-10809)))
-                                                            (if (null? 
m2-10828)
-                                                              s1-10811
+                                    (let ((expression-10622
+                                            (vector-ref e-10128 1))
+                                          (wrap-10623
+                                            (let ((w2-10633
+                                                    (vector-ref e-10128 2)))
+                                              (let ((m1-10634 (car w-10130))
+                                                    (s1-10635 (cdr w-10130)))
+                                                (if (null? m1-10634)
+                                                  (if (null? s1-10635)
+                                                    w2-10633
+                                                    (cons (car w2-10633)
+                                                          (let ((m2-10652
+                                                                  (cdr 
w2-10633)))
+                                                            (if (null? 
m2-10652)
+                                                              s1-10635
                                                               (append
-                                                                s1-10811
-                                                                m2-10828)))))
-                                                  (cons (let ((m2-10836
-                                                                (car 
w2-10809)))
-                                                          (if (null? m2-10836)
-                                                            m1-10810
+                                                                s1-10635
+                                                                m2-10652)))))
+                                                  (cons (let ((m2-10660
+                                                                (car 
w2-10633)))
+                                                          (if (null? m2-10660)
+                                                            m1-10634
                                                             (append
-                                                              m1-10810
-                                                              m2-10836)))
-                                                        (let ((m2-10844
-                                                                (cdr 
w2-10809)))
-                                                          (if (null? m2-10844)
-                                                            s1-10811
+                                                              m1-10634
+                                                              m2-10660)))
+                                                        (let ((m2-10668
+                                                                (cdr 
w2-10633)))
+                                                          (if (null? m2-10668)
+                                                            s1-10635
                                                             (append
-                                                              s1-10811
-                                                              m2-10844))))))))
-                                          (module-10800
-                                            (vector-ref e-10314 3)))
+                                                              s1-10635
+                                                              m2-10668))))))))
+                                          (module-10624
+                                            (vector-ref e-10128 3)))
                                       (vector
                                         'syntax-object
-                                        expression-10798
-                                        wrap-10799
-                                        module-10800))
-                                    (if (null? e-10314)
-                                      e-10314
+                                        expression-10622
+                                        wrap-10623
+                                        module-10624))
+                                    (if (null? e-10128)
+                                      e-10128
                                       (vector
                                         'syntax-object
-                                        e-10314
-                                        w-10316
-                                        mod-10318))))
-                                (if (if (null? (car w-10316))
-                                      (null? (cdr w-10316))
+                                        e-10128
+                                        w-10130
+                                        mod-10132))))
+                                (if (if (null? (car w-10130))
+                                      (null? (cdr w-10130))
                                       #f)
-                                  id-10352
-                                  (if (if (vector? id-10352)
-                                        (if (= (vector-length id-10352) 4)
-                                          (eq? (vector-ref id-10352 0)
+                                  id-10166
+                                  (if (if (vector? id-10166)
+                                        (if (= (vector-length id-10166) 4)
+                                          (eq? (vector-ref id-10166 0)
                                                'syntax-object)
                                           #f)
                                         #f)
-                                    (let ((expression-10896
-                                            (vector-ref id-10352 1))
-                                          (wrap-10897
-                                            (let ((w2-10907
-                                                    (vector-ref id-10352 2)))
-                                              (let ((m1-10908 (car w-10316))
-                                                    (s1-10909 (cdr w-10316)))
-                                                (if (null? m1-10908)
-                                                  (if (null? s1-10909)
-                                                    w2-10907
-                                                    (cons (car w2-10907)
-                                                          (let ((m2-10926
-                                                                  (cdr 
w2-10907)))
-                                                            (if (null? 
m2-10926)
-                                                              s1-10909
+                                    (let ((expression-10720
+                                            (vector-ref id-10166 1))
+                                          (wrap-10721
+                                            (let ((w2-10731
+                                                    (vector-ref id-10166 2)))
+                                              (let ((m1-10732 (car w-10130))
+                                                    (s1-10733 (cdr w-10130)))
+                                                (if (null? m1-10732)
+                                                  (if (null? s1-10733)
+                                                    w2-10731
+                                                    (cons (car w2-10731)
+                                                          (let ((m2-10750
+                                                                  (cdr 
w2-10731)))
+                                                            (if (null? 
m2-10750)
+                                                              s1-10733
                                                               (append
-                                                                s1-10909
-                                                                m2-10926)))))
-                                                  (cons (let ((m2-10934
-                                                                (car 
w2-10907)))
-                                                          (if (null? m2-10934)
-                                                            m1-10908
+                                                                s1-10733
+                                                                m2-10750)))))
+                                                  (cons (let ((m2-10758
+                                                                (car 
w2-10731)))
+                                                          (if (null? m2-10758)
+                                                            m1-10732
                                                             (append
-                                                              m1-10908
-                                                              m2-10934)))
-                                                        (let ((m2-10942
-                                                                (cdr 
w2-10907)))
-                                                          (if (null? m2-10942)
-                                                            s1-10909
+                                                              m1-10732
+                                                              m2-10758)))
+                                                        (let ((m2-10766
+                                                                (cdr 
w2-10731)))
+                                                          (if (null? m2-10766)
+                                                            s1-10733
                                                             (append
-                                                              s1-10909
-                                                              m2-10942))))))))
-                                          (module-10898
-                                            (vector-ref id-10352 3)))
+                                                              s1-10733
+                                                              m2-10766))))))))
+                                          (module-10722
+                                            (vector-ref id-10166 3)))
                                       (vector
                                         'syntax-object
-                                        expression-10896
-                                        wrap-10897
-                                        module-10898))
-                                    (if (null? id-10352)
-                                      id-10352
+                                        expression-10720
+                                        wrap-10721
+                                        module-10722))
+                                    (if (null? id-10166)
+                                      id-10166
                                       (vector
                                         'syntax-object
-                                        id-10352
-                                        w-10316
-                                        id-mod-10358))))))
-                            (if (eqv? type-10356 'displaced-lexical)
+                                        id-10166
+                                        w-10130
+                                        id-mod-10172))))))
+                            (if (eqv? type-10170 'displaced-lexical)
                               (syntax-violation
                                 'set!
                                 "identifier out of context"
-                                (if (if (null? (car w-10316))
-                                      (null? (cdr w-10316))
+                                (if (if (null? (car w-10130))
+                                      (null? (cdr w-10130))
                                       #f)
-                                  id-10352
-                                  (if (if (vector? id-10352)
-                                        (if (= (vector-length id-10352) 4)
-                                          (eq? (vector-ref id-10352 0)
+                                  id-10166
+                                  (if (if (vector? id-10166)
+                                        (if (= (vector-length id-10166) 4)
+                                          (eq? (vector-ref id-10166 0)
                                                'syntax-object)
                                           #f)
                                         #f)
-                                    (let ((expression-10997
-                                            (vector-ref id-10352 1))
-                                          (wrap-10998
-                                            (let ((w2-11008
-                                                    (vector-ref id-10352 2)))
-                                              (let ((m1-11009 (car w-10316))
-                                                    (s1-11010 (cdr w-10316)))
-                                                (if (null? m1-11009)
-                                                  (if (null? s1-11010)
-                                                    w2-11008
-                                                    (cons (car w2-11008)
-                                                          (let ((m2-11027
-                                                                  (cdr 
w2-11008)))
-                                                            (if (null? 
m2-11027)
-                                                              s1-11010
+                                    (let ((expression-10824
+                                            (vector-ref id-10166 1))
+                                          (wrap-10825
+                                            (let ((w2-10835
+                                                    (vector-ref id-10166 2)))
+                                              (let ((m1-10836 (car w-10130))
+                                                    (s1-10837 (cdr w-10130)))
+                                                (if (null? m1-10836)
+                                                  (if (null? s1-10837)
+                                                    w2-10835
+                                                    (cons (car w2-10835)
+                                                          (let ((m2-10854
+                                                                  (cdr 
w2-10835)))
+                                                            (if (null? 
m2-10854)
+                                                              s1-10837
                                                               (append
-                                                                s1-11010
-                                                                m2-11027)))))
-                                                  (cons (let ((m2-11035
-                                                                (car 
w2-11008)))
-                                                          (if (null? m2-11035)
-                                                            m1-11009
+                                                                s1-10837
+                                                                m2-10854)))))
+                                                  (cons (let ((m2-10862
+                                                                (car 
w2-10835)))
+                                                          (if (null? m2-10862)
+                                                            m1-10836
                                                             (append
-                                                              m1-11009
-                                                              m2-11035)))
-                                                        (let ((m2-11043
-                                                                (cdr 
w2-11008)))
-                                                          (if (null? m2-11043)
-                                                            s1-11010
+                                                              m1-10836
+                                                              m2-10862)))
+                                                        (let ((m2-10870
+                                                                (cdr 
w2-10835)))
+                                                          (if (null? m2-10870)
+                                                            s1-10837
                                                             (append
-                                                              s1-11010
-                                                              m2-11043))))))))
-                                          (module-10999
-                                            (vector-ref id-10352 3)))
+                                                              s1-10837
+                                                              m2-10870))))))))
+                                          (module-10826
+                                            (vector-ref id-10166 3)))
                                       (vector
                                         'syntax-object
-                                        expression-10997
-                                        wrap-10998
-                                        module-10999))
-                                    (if (null? id-10352)
-                                      id-10352
+                                        expression-10824
+                                        wrap-10825
+                                        module-10826))
+                                    (if (null? id-10166)
+                                      id-10166
                                       (vector
                                         'syntax-object
-                                        id-10352
-                                        w-10316
-                                        mod-10318)))))
+                                        id-10166
+                                        w-10130
+                                        mod-10132)))))
                               (syntax-violation
                                 'set!
                                 "bad set!"
-                                (let ((x-11075
+                                (let ((x-10902
                                         (begin
-                                          (if (if (pair? e-10314) s-10317 #f)
+                                          (if (if (pair? e-10128) s-10131 #f)
                                             (set-source-properties!
-                                              e-10314
-                                              s-10317))
-                                          e-10314)))
-                                  (if (if (null? (car w-10316))
-                                        (null? (cdr w-10316))
+                                              e-10128
+                                              s-10131))
+                                          e-10128)))
+                                  (if (if (null? (car w-10130))
+                                        (null? (cdr w-10130))
                                         #f)
-                                    x-11075
-                                    (if (if (vector? x-11075)
-                                          (if (= (vector-length x-11075) 4)
-                                            (eq? (vector-ref x-11075 0)
+                                    x-10902
+                                    (if (if (vector? x-10902)
+                                          (if (= (vector-length x-10902) 4)
+                                            (eq? (vector-ref x-10902 0)
                                                  'syntax-object)
                                             #f)
                                           #f)
-                                      (let ((expression-11107
-                                              (vector-ref x-11075 1))
-                                            (wrap-11108
-                                              (let ((w2-11116
-                                                      (vector-ref x-11075 2)))
-                                                (let ((m1-11117 (car w-10316))
-                                                      (s1-11118 (cdr w-10316)))
-                                                  (if (null? m1-11117)
-                                                    (if (null? s1-11118)
-                                                      w2-11116
-                                                      (cons (car w2-11116)
-                                                            (let ((m2-11133
-                                                                    (cdr 
w2-11116)))
-                                                              (if (null? 
m2-11133)
-                                                                s1-11118
+                                      (let ((expression-10934
+                                              (vector-ref x-10902 1))
+                                            (wrap-10935
+                                              (let ((w2-10943
+                                                      (vector-ref x-10902 2)))
+                                                (let ((m1-10944 (car w-10130))
+                                                      (s1-10945 (cdr w-10130)))
+                                                  (if (null? m1-10944)
+                                                    (if (null? s1-10945)
+                                                      w2-10943
+                                                      (cons (car w2-10943)
+                                                            (let ((m2-10960
+                                                                    (cdr 
w2-10943)))
+                                                              (if (null? 
m2-10960)
+                                                                s1-10945
                                                                 (append
-                                                                  s1-11118
-                                                                  m2-11133)))))
-                                                    (cons (let ((m2-11141
-                                                                  (car 
w2-11116)))
-                                                            (if (null? 
m2-11141)
-                                                              m1-11117
+                                                                  s1-10945
+                                                                  m2-10960)))))
+                                                    (cons (let ((m2-10968
+                                                                  (car 
w2-10943)))
+                                                            (if (null? 
m2-10968)
+                                                              m1-10944
                                                               (append
-                                                                m1-11117
-                                                                m2-11141)))
-                                                          (let ((m2-11149
-                                                                  (cdr 
w2-11116)))
-                                                            (if (null? 
m2-11149)
-                                                              s1-11118
+                                                                m1-10944
+                                                                m2-10968)))
+                                                          (let ((m2-10976
+                                                                  (cdr 
w2-10943)))
+                                                            (if (null? 
m2-10976)
+                                                              s1-10945
                                                               (append
-                                                                s1-11118
-                                                                
m2-11149))))))))
-                                            (module-11109
-                                              (vector-ref x-11075 3)))
+                                                                s1-10945
+                                                                
m2-10976))))))))
+                                            (module-10936
+                                              (vector-ref x-10902 3)))
                                         (vector
                                           'syntax-object
-                                          expression-11107
-                                          wrap-11108
-                                          module-11109))
-                                      (if (null? x-11075)
-                                        x-11075
+                                          expression-10934
+                                          wrap-10935
+                                          module-10936))
+                                      (if (null? x-10902)
+                                        x-10902
                                         (vector
                                           'syntax-object
-                                          x-11075
-                                          w-10316
-                                          mod-10318)))))))))))))
-                tmp-10320)
-              (let ((tmp-11164
-                      ($sc-dispatch e-10314 '(_ (any . each-any) any))))
-                (if tmp-11164
+                                          x-10902
+                                          w-10130
+                                          mod-10132)))))))))))))
+                tmp-10134)
+              (let ((tmp-10991
+                      ($sc-dispatch e-10128 '(_ (any . each-any) any))))
+                (if tmp-10991
                   (@apply
-                    (lambda (head-11168 tail-11169 val-11170)
+                    (lambda (head-10995 tail-10996 val-10997)
                       (call-with-values
                         (lambda ()
-                          (syntax-type-4585
-                            head-11168
-                            r-10315
+                          (syntax-type-4381
+                            head-10995
+                            r-10129
                             '(())
                             #f
                             #f
-                            mod-10318
+                            mod-10132
                             #t))
-                        (lambda (type-11173
-                                 value-11174
-                                 ee*-11175
-                                 ee-11176
-                                 ww-11177
-                                 ss-11178
-                                 modmod-11179)
-                          (if (eqv? type-11173 'module-ref)
-                            (let ((val-11183
-                                    (expand-4586
-                                      val-11170
-                                      r-10315
-                                      w-10316
-                                      mod-10318)))
+                        (lambda (type-11000
+                                 value-11001
+                                 ee*-11002
+                                 ee-11003
+                                 ww-11004
+                                 ss-11005
+                                 modmod-11006)
+                          (if (eqv? type-11000 'module-ref)
+                            (let ((val-11012
+                                    (expand-4382
+                                      val-10997
+                                      r-10129
+                                      w-10130
+                                      mod-10132)))
                               (call-with-values
                                 (lambda ()
-                                  (value-11174
-                                    (cons head-11168 tail-11169)
-                                    r-10315
-                                    w-10316))
-                                (lambda (e-11184
-                                         r-11185
-                                         w-11186
-                                         s*-11187
-                                         mod-11188)
-                                  (let ((tmp-11190 (list e-11184)))
+                                  (value-11001
+                                    (cons head-10995 tail-10996)
+                                    r-10129
+                                    w-10130))
+                                (lambda (e-11013
+                                         r-11014
+                                         w-11015
+                                         s*-11016
+                                         mod-11017)
+                                  (let ((tmp-11019 (list e-11013)))
                                     (if (@apply
-                                          (lambda (e-11192)
-                                            (if (symbol? e-11192)
+                                          (lambda (e-11021)
+                                            (if (symbol? e-11021)
                                               #t
-                                              (if (if (vector? e-11192)
+                                              (if (if (vector? e-11021)
                                                     (if (= (vector-length
-                                                             e-11192)
+                                                             e-11021)
                                                            4)
                                                       (eq? (vector-ref
-                                                             e-11192
+                                                             e-11021
                                                              0)
                                                            'syntax-object)
                                                       #f)
                                                     #f)
                                                 (symbol?
-                                                  (vector-ref e-11192 1))
+                                                  (vector-ref e-11021 1))
                                                 #f)))
-                                          tmp-11190)
+                                          tmp-11019)
                                       (@apply
-                                        (lambda (e-11222)
-                                          (build-global-assignment-4524
-                                            s-10317
-                                            (syntax->datum e-11222)
-                                            val-11183
-                                            mod-11188))
-                                        tmp-11190)
+                                        (lambda (e-11051)
+                                          (build-global-assignment-4320
+                                            s-10131
+                                            (syntax->datum e-11051)
+                                            val-11012
+                                            mod-11017))
+                                        tmp-11019)
                                       (syntax-violation
                                         #f
                                         "source expression failed to match any 
pattern"
-                                        e-11184))))))
-                            (build-call-4517
-                              s-10317
-                              (expand-4586
+                                        e-11013))))))
+                            (build-call-4313
+                              s-10131
+                              (expand-4382
                                 (list '#(syntax-object
                                          setter
                                          ((top)
                                           #(ribcage () () ())
+                                          #(ribcage
+                                            #(key)
+                                            #((m-*-3608 top))
+                                            #("l-*-3609"))
+                                          #(ribcage () () ())
                                           #(ribcage () () ())
                                           #(ribcage
                                             #(type value ee* ee ww ss modmod)
@@ -11153,28 +11171,28 @@
                                               (top)
                                               (top)
                                               (top))
-                                            #("l-*-3734"
-                                              "l-*-3735"
-                                              "l-*-3736"
-                                              "l-*-3737"
-                                              "l-*-3738"
-                                              "l-*-3739"
-                                              "l-*-3740"))
+                                            #("l-*-3601"
+                                              "l-*-3602"
+                                              "l-*-3603"
+                                              "l-*-3604"
+                                              "l-*-3605"
+                                              "l-*-3606"
+                                              "l-*-3607"))
                                           #(ribcage
                                             #(head tail val)
                                             #((top) (top) (top))
-                                            #("l-*-3719"
-                                              "l-*-3720"
-                                              "l-*-3721"))
+                                            #("l-*-3586"
+                                              "l-*-3587"
+                                              "l-*-3588"))
                                           #(ribcage () () ())
                                           #(ribcage
                                             #(e r w s mod)
                                             #((top) (top) (top) (top) (top))
-                                            #("l-*-3691"
-                                              "l-*-3692"
-                                              "l-*-3693"
-                                              "l-*-3694"
-                                              "l-*-3695"))
+                                            #("l-*-3560"
+                                              "l-*-3561"
+                                              "l-*-3562"
+                                              "l-*-3563"
+                                              "l-*-3564"))
                                           #(ribcage
                                             (lambda-var-list
                                               gen-var
@@ -11607,106 +11625,106 @@
                                             ("l-*-47" "l-*-46" "l-*-45"))
                                           #(ribcage () () ()))
                                          (hygiene guile))
-                                      head-11168)
-                                r-10315
-                                w-10316
-                                mod-10318)
-                              (map (lambda (e-11535)
-                                     (expand-4586
-                                       e-11535
-                                       r-10315
-                                       w-10316
-                                       mod-10318))
-                                   (append tail-11169 (list val-11170))))))))
-                    tmp-11164)
+                                      head-10995)
+                                r-10129
+                                w-10130
+                                mod-10132)
+                              (map (lambda (e-11364)
+                                     (expand-4382
+                                       e-11364
+                                       r-10129
+                                       w-10130
+                                       mod-10132))
+                                   (append tail-10996 (list val-10997))))))))
+                    tmp-10991)
                   (syntax-violation
                     'set!
                     "bad set!"
-                    (let ((x-11623
+                    (let ((x-11452
                             (begin
-                              (if (if (pair? e-10314) s-10317 #f)
-                                (set-source-properties! e-10314 s-10317))
-                              e-10314)))
-                      (if (if (null? (car w-10316))
-                            (null? (cdr w-10316))
+                              (if (if (pair? e-10128) s-10131 #f)
+                                (set-source-properties! e-10128 s-10131))
+                              e-10128)))
+                      (if (if (null? (car w-10130))
+                            (null? (cdr w-10130))
                             #f)
-                        x-11623
-                        (if (if (vector? x-11623)
-                              (if (= (vector-length x-11623) 4)
-                                (eq? (vector-ref x-11623 0) 'syntax-object)
+                        x-11452
+                        (if (if (vector? x-11452)
+                              (if (= (vector-length x-11452) 4)
+                                (eq? (vector-ref x-11452 0) 'syntax-object)
                                 #f)
                               #f)
-                          (let ((expression-11655 (vector-ref x-11623 1))
-                                (wrap-11656
-                                  (let ((w2-11664 (vector-ref x-11623 2)))
-                                    (let ((m1-11665 (car w-10316))
-                                          (s1-11666 (cdr w-10316)))
-                                      (if (null? m1-11665)
-                                        (if (null? s1-11666)
-                                          w2-11664
-                                          (cons (car w2-11664)
-                                                (let ((m2-11681
-                                                        (cdr w2-11664)))
-                                                  (if (null? m2-11681)
-                                                    s1-11666
+                          (let ((expression-11484 (vector-ref x-11452 1))
+                                (wrap-11485
+                                  (let ((w2-11493 (vector-ref x-11452 2)))
+                                    (let ((m1-11494 (car w-10130))
+                                          (s1-11495 (cdr w-10130)))
+                                      (if (null? m1-11494)
+                                        (if (null? s1-11495)
+                                          w2-11493
+                                          (cons (car w2-11493)
+                                                (let ((m2-11510
+                                                        (cdr w2-11493)))
+                                                  (if (null? m2-11510)
+                                                    s1-11495
                                                     (append
-                                                      s1-11666
-                                                      m2-11681)))))
-                                        (cons (let ((m2-11689 (car w2-11664)))
-                                                (if (null? m2-11689)
-                                                  m1-11665
-                                                  (append m1-11665 m2-11689)))
-                                              (let ((m2-11697 (cdr w2-11664)))
-                                                (if (null? m2-11697)
-                                                  s1-11666
+                                                      s1-11495
+                                                      m2-11510)))))
+                                        (cons (let ((m2-11518 (car w2-11493)))
+                                                (if (null? m2-11518)
+                                                  m1-11494
+                                                  (append m1-11494 m2-11518)))
+                                              (let ((m2-11526 (cdr w2-11493)))
+                                                (if (null? m2-11526)
+                                                  s1-11495
                                                   (append
-                                                    s1-11666
-                                                    m2-11697))))))))
-                                (module-11657 (vector-ref x-11623 3)))
+                                                    s1-11495
+                                                    m2-11526))))))))
+                                (module-11486 (vector-ref x-11452 3)))
                             (vector
                               'syntax-object
-                              expression-11655
-                              wrap-11656
-                              module-11657))
-                          (if (null? x-11623)
-                            x-11623
+                              expression-11484
+                              wrap-11485
+                              module-11486))
+                          (if (null? x-11452)
+                            x-11452
                             (vector
                               'syntax-object
-                              x-11623
-                              w-10316
-                              mod-10318))))))))))))
+                              x-11452
+                              w-10130
+                              mod-10132))))))))))))
       (module-define!
         (current-module)
         '@
         (make-syntax-transformer
           '@
           'module-ref
-          (lambda (e-11728 r-11729 w-11730)
-            (let ((tmp-11732
-                    ($sc-dispatch e-11728 '(_ each-any any))))
-              (if (if tmp-11732
+          (lambda (e-11557 r-11558 w-11559)
+            (let ((tmp-11561
+                    ($sc-dispatch e-11557 '(_ each-any any))))
+              (if (if tmp-11561
                     (@apply
-                      (lambda (mod-11735 id-11736)
-                        (if (and-map id?-4550 mod-11735)
-                          (if (symbol? id-11736)
+                      (lambda (mod-11564 id-11565)
+                        (if (and-map id?-4346 mod-11564)
+                          (if (symbol? id-11565)
                             #t
-                            (if (if (vector? id-11736)
-                                  (if (= (vector-length id-11736) 4)
-                                    (eq? (vector-ref id-11736 0)
+                            (if (if (vector? id-11565)
+                                  (if (= (vector-length id-11565) 4)
+                                    (eq? (vector-ref id-11565 0)
                                          'syntax-object)
                                     #f)
                                   #f)
-                              (symbol? (vector-ref id-11736 1))
+                              (symbol? (vector-ref id-11565 1))
                               #f))
                           #f))
-                      tmp-11732)
+                      tmp-11561)
                     #f)
                 (@apply
-                  (lambda (mod-11776 id-11777)
+                  (lambda (mod-11605 id-11606)
                     (values
-                      (syntax->datum id-11777)
-                      r-11729
-                      w-11730
+                      (syntax->datum id-11606)
+                      r-11558
+                      w-11559
                       #f
                       (syntax->datum
                         (cons '#(syntax-object
@@ -11715,12 +11733,12 @@
                                   #(ribcage
                                     #(mod id)
                                     #((top) (top))
-                                    #("l-*-3782" "l-*-3783"))
+                                    #("l-*-3650" "l-*-3651"))
                                   #(ribcage () () ())
                                   #(ribcage
                                     #(e r w)
                                     #((top) (top) (top))
-                                    #("l-*-3770" "l-*-3771" "l-*-3772"))
+                                    #("l-*-3638" "l-*-3639" "l-*-3640"))
                                   #(ribcage
                                     (lambda-var-list
                                       gen-var
@@ -12153,66 +12171,66 @@
                                     ("l-*-47" "l-*-46" "l-*-45"))
                                   #(ribcage () () ()))
                                  (hygiene guile))
-                              mod-11776))))
-                  tmp-11732)
+                              mod-11605))))
+                  tmp-11561)
                 (syntax-violation
                   #f
                   "source expression failed to match any pattern"
-                  e-11728))))))
-      (global-extend-4548
+                  e-11557))))))
+      (global-extend-4344
         'module-ref
         '@@
-        (lambda (e-11877 r-11878 w-11879)
+        (lambda (e-11706 r-11707 w-11708)
           (letrec*
-            ((remodulate-11880
-               (lambda (x-12098 mod-12099)
-                 (if (pair? x-12098)
-                   (cons (remodulate-11880 (car x-12098) mod-12099)
-                         (remodulate-11880 (cdr x-12098) mod-12099))
-                   (if (if (vector? x-12098)
-                         (if (= (vector-length x-12098) 4)
-                           (eq? (vector-ref x-12098 0) 'syntax-object)
+            ((remodulate-11709
+               (lambda (x-11927 mod-11928)
+                 (if (pair? x-11927)
+                   (cons (remodulate-11709 (car x-11927) mod-11928)
+                         (remodulate-11709 (cdr x-11927) mod-11928))
+                   (if (if (vector? x-11927)
+                         (if (= (vector-length x-11927) 4)
+                           (eq? (vector-ref x-11927 0) 'syntax-object)
                            #f)
                          #f)
-                     (let ((expression-12113
-                             (remodulate-11880
-                               (vector-ref x-12098 1)
-                               mod-12099))
-                           (wrap-12114 (vector-ref x-12098 2)))
+                     (let ((expression-11942
+                             (remodulate-11709
+                               (vector-ref x-11927 1)
+                               mod-11928))
+                           (wrap-11943 (vector-ref x-11927 2)))
                        (vector
                          'syntax-object
-                         expression-12113
-                         wrap-12114
-                         mod-12099))
-                     (if (vector? x-12098)
-                       (let ((n-12122 (vector-length x-12098)))
-                         (let ((v-12123 (make-vector n-12122)))
+                         expression-11942
+                         wrap-11943
+                         mod-11928))
+                     (if (vector? x-11927)
+                       (let ((n-11951 (vector-length x-11927)))
+                         (let ((v-11952 (make-vector n-11951)))
                            (letrec*
-                             ((loop-12124
-                                (lambda (i-12179)
-                                  (if (= i-12179 n-12122)
-                                    v-12123
+                             ((loop-11953
+                                (lambda (i-12008)
+                                  (if (= i-12008 n-11951)
+                                    v-11952
                                     (begin
                                       (vector-set!
-                                        v-12123
-                                        i-12179
-                                        (remodulate-11880
-                                          (vector-ref x-12098 i-12179)
-                                          mod-12099))
-                                      (loop-12124 (#{1+}# i-12179)))))))
-                             (loop-12124 0))))
-                       x-12098))))))
-            (let ((tmp-11882
-                    ($sc-dispatch e-11877 '(_ each-any any))))
-              (if (if tmp-11882
+                                        v-11952
+                                        i-12008
+                                        (remodulate-11709
+                                          (vector-ref x-11927 i-12008)
+                                          mod-11928))
+                                      (loop-11953 (#{1+}# i-12008)))))))
+                             (loop-11953 0))))
+                       x-11927))))))
+            (let ((tmp-11711
+                    ($sc-dispatch e-11706 '(_ each-any any))))
+              (if (if tmp-11711
                     (@apply
-                      (lambda (mod-11886 exp-11887)
-                        (and-map id?-4550 mod-11886))
-                      tmp-11882)
+                      (lambda (mod-11715 exp-11716)
+                        (and-map id?-4346 mod-11715))
+                      tmp-11711)
                     #f)
                 (@apply
-                  (lambda (mod-11903 exp-11904)
-                    (let ((mod-11905
+                  (lambda (mod-11732 exp-11733)
+                    (let ((mod-11734
                             (syntax->datum
                               (cons '#(syntax-object
                                        private
@@ -12220,15 +12238,15 @@
                                         #(ribcage
                                           #(mod exp)
                                           #((top) (top))
-                                          #("l-*-3826" "l-*-3827"))
+                                          #("l-*-3688" "l-*-3689"))
                                         #(ribcage
                                           (remodulate)
                                           ((top))
-                                          ("l-*-3793"))
+                                          ("l-*-3661"))
                                         #(ribcage
                                           #(e r w)
                                           #((top) (top) (top))
-                                          #("l-*-3790" "l-*-3791" "l-*-3792"))
+                                          #("l-*-3658" "l-*-3659" "l-*-3660"))
                                         #(ribcage
                                           (lambda-var-list
                                             gen-var
@@ -12661,155 +12679,155 @@
                                           ("l-*-47" "l-*-46" "l-*-45"))
                                         #(ribcage () () ()))
                                        (hygiene guile))
-                                    mod-11903))))
+                                    mod-11732))))
                       (values
-                        (remodulate-11880 exp-11904 mod-11905)
-                        r-11878
-                        w-11879
-                        (source-annotation-4544 exp-11904)
-                        mod-11905)))
-                  tmp-11882)
+                        (remodulate-11709 exp-11733 mod-11734)
+                        r-11707
+                        w-11708
+                        (source-annotation-4340 exp-11733)
+                        mod-11734)))
+                  tmp-11711)
                 (syntax-violation
                   #f
                   "source expression failed to match any pattern"
-                  e-11877))))))
-      (global-extend-4548
+                  e-11706))))))
+      (global-extend-4344
         'core
         'if
-        (lambda (e-12288 r-12289 w-12290 s-12291 mod-12292)
-          (let ((tmp-12294 ($sc-dispatch e-12288 '(_ any any))))
-            (if tmp-12294
+        (lambda (e-12117 r-12118 w-12119 s-12120 mod-12121)
+          (let ((tmp-12123 ($sc-dispatch e-12117 '(_ any any))))
+            (if tmp-12123
               (@apply
-                (lambda (test-12298 then-12299)
-                  (build-conditional-4518
-                    s-12291
-                    (expand-4586
-                      test-12298
-                      r-12289
-                      w-12290
-                      mod-12292)
-                    (expand-4586
-                      then-12299
-                      r-12289
-                      w-12290
-                      mod-12292)
+                (lambda (test-12127 then-12128)
+                  (build-conditional-4314
+                    s-12120
+                    (expand-4382
+                      test-12127
+                      r-12118
+                      w-12119
+                      mod-12121)
+                    (expand-4382
+                      then-12128
+                      r-12118
+                      w-12119
+                      mod-12121)
                     (make-struct/no-tail
                       (vector-ref %expanded-vtables 0)
                       #f)))
-                tmp-12294)
-              (let ((tmp-12548
-                      ($sc-dispatch e-12288 '(_ any any any))))
-                (if tmp-12548
+                tmp-12123)
+              (let ((tmp-12377
+                      ($sc-dispatch e-12117 '(_ any any any))))
+                (if tmp-12377
                   (@apply
-                    (lambda (test-12552 then-12553 else-12554)
-                      (build-conditional-4518
-                        s-12291
-                        (expand-4586
-                          test-12552
-                          r-12289
-                          w-12290
-                          mod-12292)
-                        (expand-4586
-                          then-12553
-                          r-12289
-                          w-12290
-                          mod-12292)
-                        (expand-4586
-                          else-12554
-                          r-12289
-                          w-12290
-                          mod-12292)))
-                    tmp-12548)
+                    (lambda (test-12381 then-12382 else-12383)
+                      (build-conditional-4314
+                        s-12120
+                        (expand-4382
+                          test-12381
+                          r-12118
+                          w-12119
+                          mod-12121)
+                        (expand-4382
+                          then-12382
+                          r-12118
+                          w-12119
+                          mod-12121)
+                        (expand-4382
+                          else-12383
+                          r-12118
+                          w-12119
+                          mod-12121)))
+                    tmp-12377)
                   (syntax-violation
                     #f
                     "source expression failed to match any pattern"
-                    e-12288)))))))
-      (global-extend-4548
+                    e-12117)))))))
+      (global-extend-4344
         'core
         'with-fluids
-        (lambda (e-12993 r-12994 w-12995 s-12996 mod-12997)
-          (let ((tmp-12999
+        (lambda (e-12822 r-12823 w-12824 s-12825 mod-12826)
+          (let ((tmp-12828
                   ($sc-dispatch
-                    e-12993
+                    e-12822
                     '(_ #(each (any any)) any . each-any))))
-            (if tmp-12999
+            (if tmp-12828
               (@apply
-                (lambda (fluid-13003 val-13004 b-13005 b*-13006)
-                  (build-dynlet-4519
-                    s-12996
-                    (map (lambda (x-13095)
-                           (expand-4586 x-13095 r-12994 w-12995 mod-12997))
-                         fluid-13003)
-                    (map (lambda (x-13173)
-                           (expand-4586 x-13173 r-12994 w-12995 mod-12997))
-                         val-13004)
-                    (expand-body-4590
-                      (cons b-13005 b*-13006)
-                      (let ((x-13262
+                (lambda (fluid-12832 val-12833 b-12834 b*-12835)
+                  (build-dynlet-4315
+                    s-12825
+                    (map (lambda (x-12924)
+                           (expand-4382 x-12924 r-12823 w-12824 mod-12826))
+                         fluid-12832)
+                    (map (lambda (x-13002)
+                           (expand-4382 x-13002 r-12823 w-12824 mod-12826))
+                         val-12833)
+                    (expand-body-4386
+                      (cons b-12834 b*-12835)
+                      (let ((x-13091
                               (begin
-                                (if (if (pair? e-12993) s-12996 #f)
-                                  (set-source-properties! e-12993 s-12996))
-                                e-12993)))
-                        (if (if (null? (car w-12995))
-                              (null? (cdr w-12995))
+                                (if (if (pair? e-12822) s-12825 #f)
+                                  (set-source-properties! e-12822 s-12825))
+                                e-12822)))
+                        (if (if (null? (car w-12824))
+                              (null? (cdr w-12824))
                               #f)
-                          x-13262
-                          (if (if (vector? x-13262)
-                                (if (= (vector-length x-13262) 4)
-                                  (eq? (vector-ref x-13262 0) 'syntax-object)
+                          x-13091
+                          (if (if (vector? x-13091)
+                                (if (= (vector-length x-13091) 4)
+                                  (eq? (vector-ref x-13091 0) 'syntax-object)
                                   #f)
                                 #f)
-                            (let ((expression-13294 (vector-ref x-13262 1))
-                                  (wrap-13295
-                                    (let ((w2-13303 (vector-ref x-13262 2)))
-                                      (let ((m1-13304 (car w-12995))
-                                            (s1-13305 (cdr w-12995)))
-                                        (if (null? m1-13304)
-                                          (if (null? s1-13305)
-                                            w2-13303
-                                            (cons (car w2-13303)
-                                                  (let ((m2-13320
-                                                          (cdr w2-13303)))
-                                                    (if (null? m2-13320)
-                                                      s1-13305
+                            (let ((expression-13123 (vector-ref x-13091 1))
+                                  (wrap-13124
+                                    (let ((w2-13132 (vector-ref x-13091 2)))
+                                      (let ((m1-13133 (car w-12824))
+                                            (s1-13134 (cdr w-12824)))
+                                        (if (null? m1-13133)
+                                          (if (null? s1-13134)
+                                            w2-13132
+                                            (cons (car w2-13132)
+                                                  (let ((m2-13149
+                                                          (cdr w2-13132)))
+                                                    (if (null? m2-13149)
+                                                      s1-13134
                                                       (append
-                                                        s1-13305
-                                                        m2-13320)))))
-                                          (cons (let ((m2-13328
-                                                        (car w2-13303)))
-                                                  (if (null? m2-13328)
-                                                    m1-13304
+                                                        s1-13134
+                                                        m2-13149)))))
+                                          (cons (let ((m2-13157
+                                                        (car w2-13132)))
+                                                  (if (null? m2-13157)
+                                                    m1-13133
                                                     (append
-                                                      m1-13304
-                                                      m2-13328)))
-                                                (let ((m2-13336
-                                                        (cdr w2-13303)))
-                                                  (if (null? m2-13336)
-                                                    s1-13305
+                                                      m1-13133
+                                                      m2-13157)))
+                                                (let ((m2-13165
+                                                        (cdr w2-13132)))
+                                                  (if (null? m2-13165)
+                                                    s1-13134
                                                     (append
-                                                      s1-13305
-                                                      m2-13336))))))))
-                                  (module-13296 (vector-ref x-13262 3)))
+                                                      s1-13134
+                                                      m2-13165))))))))
+                                  (module-13125 (vector-ref x-13091 3)))
                               (vector
                                 'syntax-object
-                                expression-13294
-                                wrap-13295
-                                module-13296))
-                            (if (null? x-13262)
-                              x-13262
+                                expression-13123
+                                wrap-13124
+                                module-13125))
+                            (if (null? x-13091)
+                              x-13091
                               (vector
                                 'syntax-object
-                                x-13262
-                                w-12995
-                                mod-12997)))))
-                      r-12994
-                      w-12995
-                      mod-12997)))
-                tmp-12999)
+                                x-13091
+                                w-12824
+                                mod-12826)))))
+                      r-12823
+                      w-12824
+                      mod-12826)))
+                tmp-12828)
               (syntax-violation
                 #f
                 "source expression failed to match any pattern"
-                e-12993)))))
+                e-12822)))))
       (module-define!
         (current-module)
         'begin
@@ -12839,54 +12857,54 @@
           'eval-when
           'eval-when
           '()))
-      (global-extend-4548
+      (global-extend-4344
         'core
         'syntax-case
         (letrec*
-          ((convert-pattern-13636
-             (lambda (pattern-15258 keys-15259)
+          ((convert-pattern-13465
+             (lambda (pattern-15087 keys-15088)
                (letrec*
-                 ((cvt*-15260
-                    (lambda (p*-16059 n-16060 ids-16061)
-                      (if (not (pair? p*-16059))
-                        (cvt-15262 p*-16059 n-16060 ids-16061)
+                 ((cvt*-15089
+                    (lambda (p*-15888 n-15889 ids-15890)
+                      (if (not (pair? p*-15888))
+                        (cvt-15091 p*-15888 n-15889 ids-15890)
                         (call-with-values
                           (lambda ()
-                            (cvt*-15260 (cdr p*-16059) n-16060 ids-16061))
-                          (lambda (y-16064 ids-16065)
+                            (cvt*-15089 (cdr p*-15888) n-15889 ids-15890))
+                          (lambda (y-15893 ids-15894)
                             (call-with-values
                               (lambda ()
-                                (cvt-15262 (car p*-16059) n-16060 ids-16065))
-                              (lambda (x-16068 ids-16069)
+                                (cvt-15091 (car p*-15888) n-15889 ids-15894))
+                              (lambda (x-15897 ids-15898)
                                 (values
-                                  (cons x-16068 y-16064)
-                                  ids-16069))))))))
-                  (v-reverse-15261
-                    (lambda (x-16070)
+                                  (cons x-15897 y-15893)
+                                  ids-15898))))))))
+                  (v-reverse-15090
+                    (lambda (x-15899)
                       (letrec*
-                        ((loop-16071
-                           (lambda (r-16172 x-16173)
-                             (if (not (pair? x-16173))
-                               (values r-16172 x-16173)
-                               (loop-16071
-                                 (cons (car x-16173) r-16172)
-                                 (cdr x-16173))))))
-                        (loop-16071 '() x-16070))))
-                  (cvt-15262
-                    (lambda (p-15265 n-15266 ids-15267)
-                      (if (if (symbol? p-15265)
+                        ((loop-15900
+                           (lambda (r-16001 x-16002)
+                             (if (not (pair? x-16002))
+                               (values r-16001 x-16002)
+                               (loop-15900
+                                 (cons (car x-16002) r-16001)
+                                 (cdr x-16002))))))
+                        (loop-15900 '() x-15899))))
+                  (cvt-15091
+                    (lambda (p-15094 n-15095 ids-15096)
+                      (if (if (symbol? p-15094)
                             #t
-                            (if (if (vector? p-15265)
-                                  (if (= (vector-length p-15265) 4)
-                                    (eq? (vector-ref p-15265 0) 'syntax-object)
+                            (if (if (vector? p-15094)
+                                  (if (= (vector-length p-15094) 4)
+                                    (eq? (vector-ref p-15094 0) 'syntax-object)
                                     #f)
                                   #f)
-                              (symbol? (vector-ref p-15265 1))
+                              (symbol? (vector-ref p-15094 1))
                               #f))
-                        (if (bound-id-member?-4578 p-15265 keys-15259)
-                          (values (vector 'free-id p-15265) ids-15267)
-                          (if (free-id=?-4574
-                                p-15265
+                        (if (bound-id-member?-4374 p-15094 keys-15088)
+                          (values (vector 'free-id p-15094) ids-15096)
+                          (if (free-id=?-4370
+                                p-15094
                                 '#(syntax-object
                                    _
                                    ((top)
@@ -12894,25 +12912,25 @@
                                     #(ribcage
                                       #(p n ids)
                                       #((top) (top) (top))
-                                      #("l-*-3927" "l-*-3928" "l-*-3929"))
+                                      #("l-*-3789" "l-*-3790" "l-*-3791"))
                                     #(ribcage
                                       (cvt v-reverse cvt*)
                                       ((top) (top) (top))
-                                      ("l-*-3900" "l-*-3898" "l-*-3896"))
+                                      ("l-*-3762" "l-*-3760" "l-*-3758"))
                                     #(ribcage
                                       #(pattern keys)
                                       #((top) (top))
-                                      #("l-*-3894" "l-*-3895"))
+                                      #("l-*-3756" "l-*-3757"))
                                     #(ribcage
                                       (gen-syntax-case
                                         gen-clause
                                         build-dispatch-call
                                         convert-pattern)
                                       ((top) (top) (top) (top))
-                                      ("l-*-3890"
-                                       "l-*-3888"
-                                       "l-*-3886"
-                                       "l-*-3884"))
+                                      ("l-*-3752"
+                                       "l-*-3750"
+                                       "l-*-3748"
+                                       "l-*-3746"))
                                     #(ribcage
                                       (lambda-var-list
                                         gen-var
@@ -13345,25 +13363,25 @@
                                       ("l-*-47" "l-*-46" "l-*-45"))
                                     #(ribcage () () ()))
                                    (hygiene guile)))
-                            (values '_ ids-15267)
+                            (values '_ ids-15096)
                             (values
                               'any
-                              (cons (cons p-15265 n-15266) ids-15267))))
-                        (let ((tmp-15399 ($sc-dispatch p-15265 '(any any))))
-                          (if (if tmp-15399
+                              (cons (cons p-15094 n-15095) ids-15096))))
+                        (let ((tmp-15228 ($sc-dispatch p-15094 '(any any))))
+                          (if (if tmp-15228
                                 (@apply
-                                  (lambda (x-15403 dots-15404)
-                                    (if (if (if (vector? dots-15404)
-                                              (if (= (vector-length dots-15404)
+                                  (lambda (x-15232 dots-15233)
+                                    (if (if (if (vector? dots-15233)
+                                              (if (= (vector-length dots-15233)
                                                      4)
-                                                (eq? (vector-ref dots-15404 0)
+                                                (eq? (vector-ref dots-15233 0)
                                                      'syntax-object)
                                                 #f)
                                               #f)
-                                          (symbol? (vector-ref dots-15404 1))
+                                          (symbol? (vector-ref dots-15233 1))
                                           #f)
-                                      (free-id=?-4574
-                                        dots-15404
+                                      (free-id=?-4370
+                                        dots-15233
                                         '#(syntax-object
                                            ...
                                            ((top)
@@ -13372,7 +13390,7 @@
                                             #(ribcage
                                               #(x)
                                               #((top))
-                                              #("l-*-2416"))
+                                              #("l-*-2324"))
                                             #(ribcage
                                               (lambda-var-list
                                                 gen-var
@@ -13806,43 +13824,43 @@
                                             #(ribcage () () ()))
                                            (hygiene guile)))
                                       #f))
-                                  tmp-15399)
+                                  tmp-15228)
                                 #f)
                             (@apply
-                              (lambda (x-15443 dots-15444)
+                              (lambda (x-15272 dots-15273)
                                 (call-with-values
                                   (lambda ()
-                                    (cvt-15262
-                                      x-15443
-                                      (#{1+}# n-15266)
-                                      ids-15267))
-                                  (lambda (p-15445 ids-15446)
+                                    (cvt-15091
+                                      x-15272
+                                      (#{1+}# n-15095)
+                                      ids-15096))
+                                  (lambda (p-15274 ids-15275)
                                     (values
-                                      (if (eq? p-15445 'any)
+                                      (if (eq? p-15274 'any)
                                         'each-any
-                                        (vector 'each p-15445))
-                                      ids-15446))))
-                              tmp-15399)
-                            (let ((tmp-15447
-                                    ($sc-dispatch p-15265 '(any any . any))))
-                              (if (if tmp-15447
+                                        (vector 'each p-15274))
+                                      ids-15275))))
+                              tmp-15228)
+                            (let ((tmp-15276
+                                    ($sc-dispatch p-15094 '(any any . any))))
+                              (if (if tmp-15276
                                     (@apply
-                                      (lambda (x-15451 dots-15452 ys-15453)
-                                        (if (if (if (vector? dots-15452)
+                                      (lambda (x-15280 dots-15281 ys-15282)
+                                        (if (if (if (vector? dots-15281)
                                                   (if (= (vector-length
-                                                           dots-15452)
+                                                           dots-15281)
                                                          4)
                                                     (eq? (vector-ref
-                                                           dots-15452
+                                                           dots-15281
                                                            0)
                                                          'syntax-object)
                                                     #f)
                                                   #f)
                                               (symbol?
-                                                (vector-ref dots-15452 1))
+                                                (vector-ref dots-15281 1))
                                               #f)
-                                          (free-id=?-4574
-                                            dots-15452
+                                          (free-id=?-4370
+                                            dots-15281
                                             '#(syntax-object
                                                ...
                                                ((top)
@@ -13851,7 +13869,7 @@
                                                 #(ribcage
                                                   #(x)
                                                   #((top))
-                                                  #("l-*-2416"))
+                                                  #("l-*-2324"))
                                                 #(ribcage
                                                   (lambda-var-list
                                                     gen-var
@@ -14285,156 +14303,156 @@
                                                 #(ribcage () () ()))
                                                (hygiene guile)))
                                           #f))
-                                      tmp-15447)
+                                      tmp-15276)
                                     #f)
                                 (@apply
-                                  (lambda (x-15492 dots-15493 ys-15494)
+                                  (lambda (x-15321 dots-15322 ys-15323)
                                     (call-with-values
                                       (lambda ()
-                                        (cvt*-15260
-                                          ys-15494
-                                          n-15266
-                                          ids-15267))
-                                      (lambda (ys-15979 ids-15980)
+                                        (cvt*-15089
+                                          ys-15323
+                                          n-15095
+                                          ids-15096))
+                                      (lambda (ys-15808 ids-15809)
                                         (call-with-values
                                           (lambda ()
-                                            (cvt-15262
-                                              x-15492
-                                              (#{1+}# n-15266)
-                                              ids-15980))
-                                          (lambda (x-15981 ids-15982)
+                                            (cvt-15091
+                                              x-15321
+                                              (#{1+}# n-15095)
+                                              ids-15809))
+                                          (lambda (x-15810 ids-15811)
                                             (call-with-values
                                               (lambda ()
-                                                (v-reverse-15261 ys-15979))
-                                              (lambda (ys-16018 e-16019)
+                                                (v-reverse-15090 ys-15808))
+                                              (lambda (ys-15847 e-15848)
                                                 (values
                                                   (vector
                                                     'each+
-                                                    x-15981
-                                                    ys-16018
-                                                    e-16019)
-                                                  ids-15982))))))))
-                                  tmp-15447)
-                                (let ((tmp-16020
-                                        ($sc-dispatch p-15265 '(any . any))))
-                                  (if tmp-16020
+                                                    x-15810
+                                                    ys-15847
+                                                    e-15848)
+                                                  ids-15811))))))))
+                                  tmp-15276)
+                                (let ((tmp-15849
+                                        ($sc-dispatch p-15094 '(any . any))))
+                                  (if tmp-15849
                                     (@apply
-                                      (lambda (x-16024 y-16025)
+                                      (lambda (x-15853 y-15854)
                                         (call-with-values
                                           (lambda ()
-                                            (cvt-15262
-                                              y-16025
-                                              n-15266
-                                              ids-15267))
-                                          (lambda (y-16026 ids-16027)
+                                            (cvt-15091
+                                              y-15854
+                                              n-15095
+                                              ids-15096))
+                                          (lambda (y-15855 ids-15856)
                                             (call-with-values
                                               (lambda ()
-                                                (cvt-15262
-                                                  x-16024
-                                                  n-15266
-                                                  ids-16027))
-                                              (lambda (x-16028 ids-16029)
+                                                (cvt-15091
+                                                  x-15853
+                                                  n-15095
+                                                  ids-15856))
+                                              (lambda (x-15857 ids-15858)
                                                 (values
-                                                  (cons x-16028 y-16026)
-                                                  ids-16029))))))
-                                      tmp-16020)
-                                    (let ((tmp-16030
-                                            ($sc-dispatch p-15265 '())))
-                                      (if tmp-16030
+                                                  (cons x-15857 y-15855)
+                                                  ids-15858))))))
+                                      tmp-15849)
+                                    (let ((tmp-15859
+                                            ($sc-dispatch p-15094 '())))
+                                      (if tmp-15859
                                         (@apply
-                                          (lambda () (values '() ids-15267))
-                                          tmp-16030)
-                                        (let ((tmp-16034
+                                          (lambda () (values '() ids-15096))
+                                          tmp-15859)
+                                        (let ((tmp-15863
                                                 ($sc-dispatch
-                                                  p-15265
+                                                  p-15094
                                                   '#(vector each-any))))
-                                          (if tmp-16034
+                                          (if tmp-15863
                                             (@apply
-                                              (lambda (x-16038)
+                                              (lambda (x-15867)
                                                 (call-with-values
                                                   (lambda ()
-                                                    (cvt-15262
-                                                      x-16038
-                                                      n-15266
-                                                      ids-15267))
-                                                  (lambda (p-16039 ids-16040)
+                                                    (cvt-15091
+                                                      x-15867
+                                                      n-15095
+                                                      ids-15096))
+                                                  (lambda (p-15868 ids-15869)
                                                     (values
-                                                      (vector 'vector p-16039)
-                                                      ids-16040))))
-                                              tmp-16034)
+                                                      (vector 'vector p-15868)
+                                                      ids-15869))))
+                                              tmp-15863)
                                             (values
                                               (vector
                                                 'atom
-                                                (strip-4599 p-15265 '(())))
-                                              ids-15267)))))))))))))))
-                 (cvt-15262 pattern-15258 0 '()))))
-           (build-dispatch-call-13637
-             (lambda (pvars-16174 exp-16175 y-16176 r-16177 mod-16178)
-               (let ((ids-16179 (map car pvars-16174)))
+                                                (strip-4395 p-15094 '(())))
+                                              ids-15096)))))))))))))))
+                 (cvt-15091 pattern-15087 0 '()))))
+           (build-dispatch-call-13466
+             (lambda (pvars-16003 exp-16004 y-16005 r-16006 mod-16007)
+               (let ((ids-16008 (map car pvars-16003)))
                  (begin
-                   (map cdr pvars-16174)
-                   (let ((labels-16181 (gen-labels-4553 ids-16179))
-                         (new-vars-16182 (map gen-var-4600 ids-16179)))
-                     (build-primcall-4529
+                   (map cdr pvars-16003)
+                   (let ((labels-16010 (gen-labels-4349 ids-16008))
+                         (new-vars-16011 (map gen-var-4396 ids-16008)))
+                     (build-primcall-4325
                        #f
                        'apply
-                       (list (build-simple-lambda-4526
+                       (list (build-simple-lambda-4322
                                #f
-                               (map syntax->datum ids-16179)
+                               (map syntax->datum ids-16008)
                                #f
-                               new-vars-16182
+                               new-vars-16011
                                '()
-                               (expand-4586
-                                 exp-16175
-                                 (extend-env-4545
-                                   labels-16181
-                                   (map (lambda (var-16510 level-16511)
+                               (expand-4382
+                                 exp-16004
+                                 (extend-env-4341
+                                   labels-16010
+                                   (map (lambda (var-16339 level-16340)
                                           (cons 'syntax
-                                                (cons var-16510 level-16511)))
-                                        new-vars-16182
-                                        (map cdr pvars-16174))
-                                   r-16177)
-                                 (make-binding-wrap-4564
-                                   ids-16179
-                                   labels-16181
+                                                (cons var-16339 level-16340)))
+                                        new-vars-16011
+                                        (map cdr pvars-16003))
+                                   r-16006)
+                                 (make-binding-wrap-4360
+                                   ids-16008
+                                   labels-16010
                                    '(()))
-                                 mod-16178))
-                             y-16176)))))))
-           (gen-clause-13638
-             (lambda (x-14842
-                      keys-14843
-                      clauses-14844
-                      r-14845
-                      pat-14846
-                      fender-14847
-                      exp-14848
-                      mod-14849)
+                                 mod-16007))
+                             y-16005)))))))
+           (gen-clause-13467
+             (lambda (x-14671
+                      keys-14672
+                      clauses-14673
+                      r-14674
+                      pat-14675
+                      fender-14676
+                      exp-14677
+                      mod-14678)
                (call-with-values
                  (lambda ()
-                   (convert-pattern-13636 pat-14846 keys-14843))
-                 (lambda (p-14987 pvars-14988)
-                   (if (not (distinct-bound-ids?-4577 (map car pvars-14988)))
+                   (convert-pattern-13465 pat-14675 keys-14672))
+                 (lambda (p-14816 pvars-14817)
+                   (if (not (distinct-bound-ids?-4373 (map car pvars-14817)))
                      (syntax-violation
                        'syntax-case
                        "duplicate pattern variable"
-                       pat-14846)
+                       pat-14675)
                      (if (not (and-map
-                                (lambda (x-15097)
-                                  (not (let ((x-15101 (car x-15097)))
-                                         (if (if (if (vector? x-15101)
+                                (lambda (x-14926)
+                                  (not (let ((x-14930 (car x-14926)))
+                                         (if (if (if (vector? x-14930)
                                                    (if (= (vector-length
-                                                            x-15101)
+                                                            x-14930)
                                                           4)
                                                      (eq? (vector-ref
-                                                            x-15101
+                                                            x-14930
                                                             0)
                                                           'syntax-object)
                                                      #f)
                                                    #f)
-                                               (symbol? (vector-ref x-15101 1))
+                                               (symbol? (vector-ref x-14930 1))
                                                #f)
-                                           (free-id=?-4574
-                                             x-15101
+                                           (free-id=?-4370
+                                             x-14930
                                              '#(syntax-object
                                                 ...
                                                 ((top)
@@ -14443,7 +14461,7 @@
                                                  #(ribcage
                                                    #(x)
                                                    #((top))
-                                                   #("l-*-2416"))
+                                                   #("l-*-2324"))
                                                  #(ribcage
                                                    (lambda-var-list
                                                      gen-var
@@ -14879,43 +14897,43 @@
                                                  #(ribcage () () ()))
                                                 (hygiene guile)))
                                            #f))))
-                                pvars-14988))
+                                pvars-14817))
                        (syntax-violation
                          'syntax-case
                          "misplaced ellipsis"
-                         pat-14846)
-                       (let ((y-15126
+                         pat-14675)
+                       (let ((y-14955
                                (gensym
                                  (string-append (symbol->string 'tmp) "-"))))
-                         (let ((fun-exp-15131
-                                 (let ((req-15140 (list 'tmp))
-                                       (vars-15142 (list y-15126))
-                                       (exp-15144
-                                         (let ((y-15173
+                         (let ((fun-exp-14960
+                                 (let ((req-14969 (list 'tmp))
+                                       (vars-14971 (list y-14955))
+                                       (exp-14973
+                                         (let ((y-15002
                                                  (make-struct/no-tail
                                                    (vector-ref
                                                      %expanded-vtables
                                                      3)
                                                    #f
                                                    'tmp
-                                                   y-15126)))
-                                           (let ((test-exp-15177
-                                                   (let ((tmp-15186
+                                                   y-14955)))
+                                           (let ((test-exp-15006
+                                                   (let ((tmp-15015
                                                            ($sc-dispatch
-                                                             fender-14847
+                                                             fender-14676
                                                              '#(atom #t))))
-                                                     (if tmp-15186
+                                                     (if tmp-15015
                                                        (@apply
-                                                         (lambda () y-15173)
-                                                         tmp-15186)
-                                                       (let ((then-exp-15204
-                                                               
(build-dispatch-call-13637
-                                                                 pvars-14988
-                                                                 fender-14847
-                                                                 y-15173
-                                                                 r-14845
-                                                                 mod-14849))
-                                                             (else-exp-15205
+                                                         (lambda () y-15002)
+                                                         tmp-15015)
+                                                       (let ((then-exp-15033
+                                                               
(build-dispatch-call-13466
+                                                                 pvars-14817
+                                                                 fender-14676
+                                                                 y-15002
+                                                                 r-14674
+                                                                 mod-14678))
+                                                             (else-exp-15034
                                                                
(make-struct/no-tail
                                                                  (vector-ref
                                                                    
%expanded-vtables
@@ -14927,82 +14945,82 @@
                                                              %expanded-vtables
                                                              10)
                                                            #f
-                                                           y-15173
-                                                           then-exp-15204
-                                                           else-exp-15205)))))
-                                                 (then-exp-15178
-                                                   (build-dispatch-call-13637
-                                                     pvars-14988
-                                                     exp-14848
-                                                     y-15173
-                                                     r-14845
-                                                     mod-14849))
-                                                 (else-exp-15179
-                                                   (gen-syntax-case-13639
-                                                     x-14842
-                                                     keys-14843
-                                                     clauses-14844
-                                                     r-14845
-                                                     mod-14849)))
+                                                           y-15002
+                                                           then-exp-15033
+                                                           else-exp-15034)))))
+                                                 (then-exp-15007
+                                                   (build-dispatch-call-13466
+                                                     pvars-14817
+                                                     exp-14677
+                                                     y-15002
+                                                     r-14674
+                                                     mod-14678))
+                                                 (else-exp-15008
+                                                   (gen-syntax-case-13468
+                                                     x-14671
+                                                     keys-14672
+                                                     clauses-14673
+                                                     r-14674
+                                                     mod-14678)))
                                              (make-struct/no-tail
                                                (vector-ref
                                                  %expanded-vtables
                                                  10)
                                                #f
-                                               test-exp-15177
-                                               then-exp-15178
-                                               else-exp-15179)))))
-                                   (let ((body-15149
+                                               test-exp-15006
+                                               then-exp-15007
+                                               else-exp-15008)))))
+                                   (let ((body-14978
                                            (make-struct/no-tail
                                              (vector-ref %expanded-vtables 15)
                                              #f
-                                             req-15140
+                                             req-14969
                                              #f
                                              #f
                                              #f
                                              '()
-                                             vars-15142
-                                             exp-15144
+                                             vars-14971
+                                             exp-14973
                                              #f)))
                                      (make-struct/no-tail
                                        (vector-ref %expanded-vtables 14)
                                        #f
                                        '()
-                                       body-15149))))
-                               (arg-exps-15132
-                                 (list (if (eq? p-14987 'any)
-                                         (let ((args-15237 (list x-14842)))
+                                       body-14978))))
+                               (arg-exps-14961
+                                 (list (if (eq? p-14816 'any)
+                                         (let ((args-15066 (list x-14671)))
                                            (make-struct/no-tail
                                              (vector-ref %expanded-vtables 12)
                                              #f
                                              'list
-                                             args-15237))
-                                         (let ((args-15246
-                                                 (list x-14842
+                                             args-15066))
+                                         (let ((args-15075
+                                                 (list x-14671
                                                        (make-struct/no-tail
                                                          (vector-ref
                                                            %expanded-vtables
                                                            1)
                                                          #f
-                                                         p-14987))))
+                                                         p-14816))))
                                            (make-struct/no-tail
                                              (vector-ref %expanded-vtables 12)
                                              #f
                                              '$sc-dispatch
-                                             args-15246))))))
+                                             args-15075))))))
                            (make-struct/no-tail
                              (vector-ref %expanded-vtables 11)
                              #f
-                             fun-exp-15131
-                             arg-exps-15132)))))))))
-           (gen-syntax-case-13639
-             (lambda (x-14343
-                      keys-14344
-                      clauses-14345
-                      r-14346
-                      mod-14347)
-               (if (null? clauses-14345)
-                 (let ((args-14353
+                             fun-exp-14960
+                             arg-exps-14961)))))))))
+           (gen-syntax-case-13468
+             (lambda (x-14172
+                      keys-14173
+                      clauses-14174
+                      r-14175
+                      mod-14176)
+               (if (null? clauses-14174)
+                 (let ((args-14182
                          (list (make-struct/no-tail
                                  (vector-ref %expanded-vtables 1)
                                  #f
@@ -15011,56 +15029,56 @@
                                  (vector-ref %expanded-vtables 1)
                                  #f
                                  "source expression failed to match any 
pattern")
-                               x-14343)))
+                               x-14172)))
                    (make-struct/no-tail
                      (vector-ref %expanded-vtables 12)
                      #f
                      'syntax-violation
-                     args-14353))
-                 (let ((tmp-14372 (car clauses-14345)))
-                   (let ((tmp-14373 ($sc-dispatch tmp-14372 '(any any))))
-                     (if tmp-14373
+                     args-14182))
+                 (let ((tmp-14201 (car clauses-14174)))
+                   (let ((tmp-14202 ($sc-dispatch tmp-14201 '(any any))))
+                     (if tmp-14202
                        (@apply
-                         (lambda (pat-14375 exp-14376)
-                           (if (if (if (symbol? pat-14375)
+                         (lambda (pat-14204 exp-14205)
+                           (if (if (if (symbol? pat-14204)
                                      #t
-                                     (if (if (vector? pat-14375)
-                                           (if (= (vector-length pat-14375) 4)
-                                             (eq? (vector-ref pat-14375 0)
+                                     (if (if (vector? pat-14204)
+                                           (if (= (vector-length pat-14204) 4)
+                                             (eq? (vector-ref pat-14204 0)
                                                   'syntax-object)
                                              #f)
                                            #f)
-                                       (symbol? (vector-ref pat-14375 1))
+                                       (symbol? (vector-ref pat-14204 1))
                                        #f))
                                  (and-map
-                                   (lambda (x-14403)
-                                     (not (free-id=?-4574 pat-14375 x-14403)))
+                                   (lambda (x-14232)
+                                     (not (free-id=?-4370 pat-14204 x-14232)))
                                    (cons '#(syntax-object
                                             ...
                                             ((top)
                                              #(ribcage
                                                #(pat exp)
                                                #((top) (top))
-                                               #("l-*-4087" "l-*-4088"))
+                                               #("l-*-3941" "l-*-3942"))
                                              #(ribcage () () ())
                                              #(ribcage
                                                #(x keys clauses r mod)
                                                #((top) (top) (top) (top) (top))
-                                               #("l-*-4077"
-                                                 "l-*-4078"
-                                                 "l-*-4079"
-                                                 "l-*-4080"
-                                                 "l-*-4081"))
+                                               #("l-*-3931"
+                                                 "l-*-3932"
+                                                 "l-*-3933"
+                                                 "l-*-3934"
+                                                 "l-*-3935"))
                                              #(ribcage
                                                (gen-syntax-case
                                                  gen-clause
                                                  build-dispatch-call
                                                  convert-pattern)
                                                ((top) (top) (top) (top))
-                                               ("l-*-3890"
-                                                "l-*-3888"
-                                                "l-*-3886"
-                                                "l-*-3884"))
+                                               ("l-*-3752"
+                                                "l-*-3750"
+                                                "l-*-3748"
+                                                "l-*-3746"))
                                              #(ribcage
                                                (lambda-var-list
                                                  gen-var
@@ -15493,35 +15511,35 @@
                                                ("l-*-47" "l-*-46" "l-*-45"))
                                              #(ribcage () () ()))
                                             (hygiene guile))
-                                         keys-14344))
+                                         keys-14173))
                                  #f)
-                             (if (free-id=?-4574
+                             (if (free-id=?-4370
                                    '#(syntax-object
                                       pad
                                       ((top)
                                        #(ribcage
                                          #(pat exp)
                                          #((top) (top))
-                                         #("l-*-4087" "l-*-4088"))
+                                         #("l-*-3941" "l-*-3942"))
                                        #(ribcage () () ())
                                        #(ribcage
                                          #(x keys clauses r mod)
                                          #((top) (top) (top) (top) (top))
-                                         #("l-*-4077"
-                                           "l-*-4078"
-                                           "l-*-4079"
-                                           "l-*-4080"
-                                           "l-*-4081"))
+                                         #("l-*-3931"
+                                           "l-*-3932"
+                                           "l-*-3933"
+                                           "l-*-3934"
+                                           "l-*-3935"))
                                        #(ribcage
                                          (gen-syntax-case
                                            gen-clause
                                            build-dispatch-call
                                            convert-pattern)
                                          ((top) (top) (top) (top))
-                                         ("l-*-3890"
-                                          "l-*-3888"
-                                          "l-*-3886"
-                                          "l-*-3884"))
+                                         ("l-*-3752"
+                                          "l-*-3750"
+                                          "l-*-3748"
+                                          "l-*-3746"))
                                        #(ribcage
                                          (lambda-var-list
                                            gen-var
@@ -15960,26 +15978,26 @@
                                        #(ribcage
                                          #(pat exp)
                                          #((top) (top))
-                                         #("l-*-4087" "l-*-4088"))
+                                         #("l-*-3941" "l-*-3942"))
                                        #(ribcage () () ())
                                        #(ribcage
                                          #(x keys clauses r mod)
                                          #((top) (top) (top) (top) (top))
-                                         #("l-*-4077"
-                                           "l-*-4078"
-                                           "l-*-4079"
-                                           "l-*-4080"
-                                           "l-*-4081"))
+                                         #("l-*-3931"
+                                           "l-*-3932"
+                                           "l-*-3933"
+                                           "l-*-3934"
+                                           "l-*-3935"))
                                        #(ribcage
                                          (gen-syntax-case
                                            gen-clause
                                            build-dispatch-call
                                            convert-pattern)
                                          ((top) (top) (top) (top))
-                                         ("l-*-3890"
-                                          "l-*-3888"
-                                          "l-*-3886"
-                                          "l-*-3884"))
+                                         ("l-*-3752"
+                                          "l-*-3750"
+                                          "l-*-3748"
+                                          "l-*-3746"))
                                        #(ribcage
                                          (lambda-var-list
                                            gen-var
@@ -16412,166 +16430,166 @@
                                          ("l-*-47" "l-*-46" "l-*-45"))
                                        #(ribcage () () ()))
                                       (hygiene guile)))
-                               (expand-4586 exp-14376 r-14346 '(()) mod-14347)
-                               (let ((labels-14485
+                               (expand-4382 exp-14205 r-14175 '(()) mod-14176)
+                               (let ((labels-14314
                                        (list (string-append
                                                "l-"
-                                               (session-id-4511)
+                                               (session-id-4307)
                                                (symbol->string (gensym "-")))))
-                                     (var-14486
-                                       (let ((id-14524
-                                               (if (if (vector? pat-14375)
+                                     (var-14315
+                                       (let ((id-14353
+                                               (if (if (vector? pat-14204)
                                                      (if (= (vector-length
-                                                              pat-14375)
+                                                              pat-14204)
                                                             4)
                                                        (eq? (vector-ref
-                                                              pat-14375
+                                                              pat-14204
                                                               0)
                                                             'syntax-object)
                                                        #f)
                                                      #f)
-                                                 (vector-ref pat-14375 1)
-                                                 pat-14375)))
+                                                 (vector-ref pat-14204 1)
+                                                 pat-14204)))
                                          (gensym
                                            (string-append
-                                             (symbol->string id-14524)
+                                             (symbol->string id-14353)
                                              "-")))))
-                                 (build-call-4517
+                                 (build-call-4313
                                    #f
-                                   (build-simple-lambda-4526
+                                   (build-simple-lambda-4322
                                      #f
-                                     (list (syntax->datum pat-14375))
+                                     (list (syntax->datum pat-14204))
                                      #f
-                                     (list var-14486)
+                                     (list var-14315)
                                      '()
-                                     (expand-4586
-                                       exp-14376
-                                       (extend-env-4545
-                                         labels-14485
+                                     (expand-4382
+                                       exp-14205
+                                       (extend-env-4341
+                                         labels-14314
                                          (list (cons 'syntax
-                                                     (cons var-14486 0)))
-                                         r-14346)
-                                       (make-binding-wrap-4564
-                                         (list pat-14375)
-                                         labels-14485
+                                                     (cons var-14315 0)))
+                                         r-14175)
+                                       (make-binding-wrap-4360
+                                         (list pat-14204)
+                                         labels-14314
                                          '(()))
-                                       mod-14347))
-                                   (list x-14343))))
-                             (gen-clause-13638
-                               x-14343
-                               keys-14344
-                               (cdr clauses-14345)
-                               r-14346
-                               pat-14375
+                                       mod-14176))
+                                   (list x-14172))))
+                             (gen-clause-13467
+                               x-14172
+                               keys-14173
+                               (cdr clauses-14174)
+                               r-14175
+                               pat-14204
                                #t
-                               exp-14376
-                               mod-14347)))
-                         tmp-14373)
-                       (let ((tmp-14834
-                               ($sc-dispatch tmp-14372 '(any any any))))
-                         (if tmp-14834
+                               exp-14205
+                               mod-14176)))
+                         tmp-14202)
+                       (let ((tmp-14663
+                               ($sc-dispatch tmp-14201 '(any any any))))
+                         (if tmp-14663
                            (@apply
-                             (lambda (pat-14836 fender-14837 exp-14838)
-                               (gen-clause-13638
-                                 x-14343
-                                 keys-14344
-                                 (cdr clauses-14345)
-                                 r-14346
-                                 pat-14836
-                                 fender-14837
-                                 exp-14838
-                                 mod-14347))
-                             tmp-14834)
+                             (lambda (pat-14665 fender-14666 exp-14667)
+                               (gen-clause-13467
+                                 x-14172
+                                 keys-14173
+                                 (cdr clauses-14174)
+                                 r-14175
+                                 pat-14665
+                                 fender-14666
+                                 exp-14667
+                                 mod-14176))
+                             tmp-14663)
                            (syntax-violation
                              'syntax-case
                              "invalid clause"
-                             (car clauses-14345)))))))))))
-          (lambda (e-13640 r-13641 w-13642 s-13643 mod-13644)
-            (let ((e-13645
-                    (let ((x-14254
+                             (car clauses-14174)))))))))))
+          (lambda (e-13469 r-13470 w-13471 s-13472 mod-13473)
+            (let ((e-13474
+                    (let ((x-14083
                             (begin
-                              (if (if (pair? e-13640) s-13643 #f)
-                                (set-source-properties! e-13640 s-13643))
-                              e-13640)))
-                      (if (if (null? (car w-13642))
-                            (null? (cdr w-13642))
+                              (if (if (pair? e-13469) s-13472 #f)
+                                (set-source-properties! e-13469 s-13472))
+                              e-13469)))
+                      (if (if (null? (car w-13471))
+                            (null? (cdr w-13471))
                             #f)
-                        x-14254
-                        (if (if (vector? x-14254)
-                              (if (= (vector-length x-14254) 4)
-                                (eq? (vector-ref x-14254 0) 'syntax-object)
+                        x-14083
+                        (if (if (vector? x-14083)
+                              (if (= (vector-length x-14083) 4)
+                                (eq? (vector-ref x-14083 0) 'syntax-object)
                                 #f)
                               #f)
-                          (let ((expression-14286 (vector-ref x-14254 1))
-                                (wrap-14287
-                                  (let ((w2-14295 (vector-ref x-14254 2)))
-                                    (let ((m1-14296 (car w-13642))
-                                          (s1-14297 (cdr w-13642)))
-                                      (if (null? m1-14296)
-                                        (if (null? s1-14297)
-                                          w2-14295
-                                          (cons (car w2-14295)
-                                                (let ((m2-14312
-                                                        (cdr w2-14295)))
-                                                  (if (null? m2-14312)
-                                                    s1-14297
+                          (let ((expression-14115 (vector-ref x-14083 1))
+                                (wrap-14116
+                                  (let ((w2-14124 (vector-ref x-14083 2)))
+                                    (let ((m1-14125 (car w-13471))
+                                          (s1-14126 (cdr w-13471)))
+                                      (if (null? m1-14125)
+                                        (if (null? s1-14126)
+                                          w2-14124
+                                          (cons (car w2-14124)
+                                                (let ((m2-14141
+                                                        (cdr w2-14124)))
+                                                  (if (null? m2-14141)
+                                                    s1-14126
                                                     (append
-                                                      s1-14297
-                                                      m2-14312)))))
-                                        (cons (let ((m2-14320 (car w2-14295)))
-                                                (if (null? m2-14320)
-                                                  m1-14296
-                                                  (append m1-14296 m2-14320)))
-                                              (let ((m2-14328 (cdr w2-14295)))
-                                                (if (null? m2-14328)
-                                                  s1-14297
+                                                      s1-14126
+                                                      m2-14141)))))
+                                        (cons (let ((m2-14149 (car w2-14124)))
+                                                (if (null? m2-14149)
+                                                  m1-14125
+                                                  (append m1-14125 m2-14149)))
+                                              (let ((m2-14157 (cdr w2-14124)))
+                                                (if (null? m2-14157)
+                                                  s1-14126
                                                   (append
-                                                    s1-14297
-                                                    m2-14328))))))))
-                                (module-14288 (vector-ref x-14254 3)))
+                                                    s1-14126
+                                                    m2-14157))))))))
+                                (module-14117 (vector-ref x-14083 3)))
                             (vector
                               'syntax-object
-                              expression-14286
-                              wrap-14287
-                              module-14288))
-                          (if (null? x-14254)
-                            x-14254
+                              expression-14115
+                              wrap-14116
+                              module-14117))
+                          (if (null? x-14083)
+                            x-14083
                             (vector
                               'syntax-object
-                              x-14254
-                              w-13642
-                              mod-13644)))))))
-              (let ((tmp-13646 e-13645))
-                (let ((tmp-13647
+                              x-14083
+                              w-13471
+                              mod-13473)))))))
+              (let ((tmp-13475 e-13474))
+                (let ((tmp-13476
                         ($sc-dispatch
-                          tmp-13646
+                          tmp-13475
                           '(_ any each-any . each-any))))
-                  (if tmp-13647
+                  (if tmp-13476
                     (@apply
-                      (lambda (val-13695 key-13696 m-13697)
+                      (lambda (val-13524 key-13525 m-13526)
                         (if (and-map
-                              (lambda (x-13698)
-                                (if (if (symbol? x-13698)
+                              (lambda (x-13527)
+                                (if (if (symbol? x-13527)
                                       #t
-                                      (if (if (vector? x-13698)
-                                            (if (= (vector-length x-13698) 4)
-                                              (eq? (vector-ref x-13698 0)
+                                      (if (if (vector? x-13527)
+                                            (if (= (vector-length x-13527) 4)
+                                              (eq? (vector-ref x-13527 0)
                                                    'syntax-object)
                                               #f)
                                             #f)
-                                        (symbol? (vector-ref x-13698 1))
+                                        (symbol? (vector-ref x-13527 1))
                                         #f))
-                                  (not (if (if (if (vector? x-13698)
-                                                 (if (= (vector-length x-13698)
+                                  (not (if (if (if (vector? x-13527)
+                                                 (if (= (vector-length x-13527)
                                                         4)
-                                                   (eq? (vector-ref x-13698 0)
+                                                   (eq? (vector-ref x-13527 0)
                                                         'syntax-object)
                                                    #f)
                                                  #f)
-                                             (symbol? (vector-ref x-13698 1))
+                                             (symbol? (vector-ref x-13527 1))
                                              #f)
-                                         (free-id=?-4574
-                                           x-13698
+                                         (free-id=?-4370
+                                           x-13527
                                            '#(syntax-object
                                               ...
                                               ((top)
@@ -16580,7 +16598,7 @@
                                                #(ribcage
                                                  #(x)
                                                  #((top))
-                                                 #("l-*-2416"))
+                                                 #("l-*-2324"))
                                                #(ribcage
                                                  (lambda-var-list
                                                    gen-var
@@ -17015,865 +17033,867 @@
                                               (hygiene guile)))
                                          #f))
                                   #f))
-                              key-13696)
-                          (let ((x-13763
+                              key-13525)
+                          (let ((x-13592
                                   (gensym
                                     (string-append
                                       (symbol->string 'tmp)
                                       "-"))))
-                            (build-call-4517
-                              s-13643
-                              (let ((req-13901 (list 'tmp))
-                                    (vars-13903 (list x-13763))
-                                    (exp-13905
-                                      (gen-syntax-case-13639
+                            (build-call-4313
+                              s-13472
+                              (let ((req-13730 (list 'tmp))
+                                    (vars-13732 (list x-13592))
+                                    (exp-13734
+                                      (gen-syntax-case-13468
                                         (make-struct/no-tail
                                           (vector-ref %expanded-vtables 3)
                                           #f
                                           'tmp
-                                          x-13763)
-                                        key-13696
-                                        m-13697
-                                        r-13641
-                                        mod-13644)))
-                                (let ((body-13910
+                                          x-13592)
+                                        key-13525
+                                        m-13526
+                                        r-13470
+                                        mod-13473)))
+                                (let ((body-13739
                                         (make-struct/no-tail
                                           (vector-ref %expanded-vtables 15)
                                           #f
-                                          req-13901
+                                          req-13730
                                           #f
                                           #f
                                           #f
                                           '()
-                                          vars-13903
-                                          exp-13905
+                                          vars-13732
+                                          exp-13734
                                           #f)))
                                   (make-struct/no-tail
                                     (vector-ref %expanded-vtables 14)
                                     #f
                                     '()
-                                    body-13910)))
-                              (list (expand-4586
-                                      val-13695
-                                      r-13641
+                                    body-13739)))
+                              (list (expand-4382
+                                      val-13524
+                                      r-13470
                                       '(())
-                                      mod-13644))))
+                                      mod-13473))))
                           (syntax-violation
                             'syntax-case
                             "invalid literals list"
-                            e-13645)))
-                      tmp-13647)
+                            e-13474)))
+                      tmp-13476)
                     (syntax-violation
                       #f
                       "source expression failed to match any pattern"
-                      tmp-13646))))))))
+                      tmp-13475))))))))
       (set! macroexpand
         (lambda*
-          (x-16590
+          (x-16419
             #:optional
-            (m-16591 'e)
-            (esew-16592 '(eval)))
-          (expand-top-sequence-4582
-            (list x-16590)
+            (m-16420 'e)
+            (esew-16421 '(eval)))
+          (expand-top-sequence-4378
+            (list x-16419)
             '()
             '((top))
             #f
-            m-16591
-            esew-16592
+            m-16420
+            esew-16421
             (cons 'hygiene (module-name (current-module))))))
       (set! identifier?
-        (lambda (x-16595)
-          (if (if (vector? x-16595)
-                (if (= (vector-length x-16595) 4)
-                  (eq? (vector-ref x-16595 0) 'syntax-object)
+        (lambda (x-16424)
+          (if (if (vector? x-16424)
+                (if (= (vector-length x-16424) 4)
+                  (eq? (vector-ref x-16424 0) 'syntax-object)
                   #f)
                 #f)
-            (symbol? (vector-ref x-16595 1))
+            (symbol? (vector-ref x-16424 1))
             #f)))
       (set! datum->syntax
-        (lambda (id-16620 datum-16621)
-          (let ((wrap-16626 (vector-ref id-16620 2))
-                (module-16627 (vector-ref id-16620 3)))
+        (lambda (id-16449 datum-16450)
+          (let ((wrap-16455 (vector-ref id-16449 2))
+                (module-16456 (vector-ref id-16449 3)))
             (vector
               'syntax-object
-              datum-16621
-              wrap-16626
-              module-16627))))
+              datum-16450
+              wrap-16455
+              module-16456))))
       (set! syntax->datum
-        (lambda (x-16634) (strip-4599 x-16634 '(()))))
+        (lambda (x-16463) (strip-4395 x-16463 '(()))))
       (set! syntax-source
-        (lambda (x-16637)
-          (source-annotation-4544 x-16637)))
+        (lambda (x-16466)
+          (source-annotation-4340 x-16466)))
       (set! generate-temporaries
-        (lambda (ls-16821)
+        (lambda (ls-16650)
           (begin
-            (if (not (list? ls-16821))
+            (if (not (list? ls-16650))
               (syntax-violation
                 'generate-temporaries
                 "invalid argument"
-                ls-16821))
-            (let ((mod-16829
+                ls-16650))
+            (let ((mod-16658
                     (cons 'hygiene (module-name (current-module)))))
-              (map (lambda (x-16830)
-                     (let ((x-16834 (gensym "t-")))
-                       (if (if (vector? x-16834)
-                             (if (= (vector-length x-16834) 4)
-                               (eq? (vector-ref x-16834 0) 'syntax-object)
+              (map (lambda (x-16659)
+                     (let ((x-16663 (gensym "t-")))
+                       (if (if (vector? x-16663)
+                             (if (= (vector-length x-16663) 4)
+                               (eq? (vector-ref x-16663 0) 'syntax-object)
                                #f)
                              #f)
-                         (let ((expression-16849 (vector-ref x-16834 1))
-                               (wrap-16850
-                                 (let ((w2-16858 (vector-ref x-16834 2)))
-                                   (cons (let ((m2-16865 (car w2-16858)))
-                                           (if (null? m2-16865)
+                         (let ((expression-16678 (vector-ref x-16663 1))
+                               (wrap-16679
+                                 (let ((w2-16687 (vector-ref x-16663 2)))
+                                   (cons (let ((m2-16694 (car w2-16687)))
+                                           (if (null? m2-16694)
                                              '(top)
-                                             (append '(top) m2-16865)))
-                                         (let ((m2-16872 (cdr w2-16858)))
-                                           (if (null? m2-16872)
+                                             (append '(top) m2-16694)))
+                                         (let ((m2-16701 (cdr w2-16687)))
+                                           (if (null? m2-16701)
                                              '()
-                                             (append '() m2-16872))))))
-                               (module-16851 (vector-ref x-16834 3)))
+                                             (append '() m2-16701))))))
+                               (module-16680 (vector-ref x-16663 3)))
                            (vector
                              'syntax-object
-                             expression-16849
-                             wrap-16850
-                             module-16851))
-                         (if (null? x-16834)
-                           x-16834
+                             expression-16678
+                             wrap-16679
+                             module-16680))
+                         (if (null? x-16663)
+                           x-16663
                            (vector
                              'syntax-object
-                             x-16834
+                             x-16663
                              '((top))
-                             mod-16829)))))
-                   ls-16821)))))
+                             mod-16658)))))
+                   ls-16650)))))
       (set! free-identifier=?
-        (lambda (x-16881 y-16882)
+        (lambda (x-16710 y-16711)
           (begin
-            (if (not (if (if (vector? x-16881)
-                           (if (= (vector-length x-16881) 4)
-                             (eq? (vector-ref x-16881 0) 'syntax-object)
+            (if (not (if (if (vector? x-16710)
+                           (if (= (vector-length x-16710) 4)
+                             (eq? (vector-ref x-16710 0) 'syntax-object)
                              #f)
                            #f)
-                       (symbol? (vector-ref x-16881 1))
+                       (symbol? (vector-ref x-16710 1))
                        #f))
               (syntax-violation
                 'free-identifier=?
                 "invalid argument"
-                x-16881))
-            (if (not (if (if (vector? y-16882)
-                           (if (= (vector-length y-16882) 4)
-                             (eq? (vector-ref y-16882 0) 'syntax-object)
+                x-16710))
+            (if (not (if (if (vector? y-16711)
+                           (if (= (vector-length y-16711) 4)
+                             (eq? (vector-ref y-16711 0) 'syntax-object)
                              #f)
                            #f)
-                       (symbol? (vector-ref y-16882 1))
+                       (symbol? (vector-ref y-16711 1))
                        #f))
               (syntax-violation
                 'free-identifier=?
                 "invalid argument"
-                y-16882))
-            (free-id=?-4574 x-16881 y-16882))))
+                y-16711))
+            (free-id=?-4370 x-16710 y-16711))))
       (set! bound-identifier=?
-        (lambda (x-16957 y-16958)
+        (lambda (x-16786 y-16787)
           (begin
-            (if (not (if (if (vector? x-16957)
-                           (if (= (vector-length x-16957) 4)
-                             (eq? (vector-ref x-16957 0) 'syntax-object)
+            (if (not (if (if (vector? x-16786)
+                           (if (= (vector-length x-16786) 4)
+                             (eq? (vector-ref x-16786 0) 'syntax-object)
                              #f)
                            #f)
-                       (symbol? (vector-ref x-16957 1))
+                       (symbol? (vector-ref x-16786 1))
                        #f))
               (syntax-violation
                 'bound-identifier=?
                 "invalid argument"
-                x-16957))
-            (if (not (if (if (vector? y-16958)
-                           (if (= (vector-length y-16958) 4)
-                             (eq? (vector-ref y-16958 0) 'syntax-object)
+                x-16786))
+            (if (not (if (if (vector? y-16787)
+                           (if (= (vector-length y-16787) 4)
+                             (eq? (vector-ref y-16787 0) 'syntax-object)
                              #f)
                            #f)
-                       (symbol? (vector-ref y-16958 1))
+                       (symbol? (vector-ref y-16787 1))
                        #f))
               (syntax-violation
                 'bound-identifier=?
                 "invalid argument"
-                y-16958))
-            (bound-id=?-4575 x-16957 y-16958))))
+                y-16787))
+            (bound-id=?-4371 x-16786 y-16787))))
       (set! syntax-violation
         (lambda*
-          (who-17124
-            message-17125
-            form-17126
+          (who-16953
+            message-16954
+            form-16955
             #:optional
-            (subform-17127 #f))
+            (subform-16956 #f))
           (begin
-            (if (not (if (not who-17124)
-                       (not who-17124)
-                       (let ((t-17145 (string? who-17124)))
-                         (if t-17145 t-17145 (symbol? who-17124)))))
+            (if (not (if (not who-16953)
+                       (not who-16953)
+                       (let ((t-16974 (string? who-16953)))
+                         (if t-16974 t-16974 (symbol? who-16953)))))
               (syntax-violation
                 'syntax-violation
                 "invalid argument"
-                who-17124))
-            (if (not (string? message-17125))
+                who-16953))
+            (if (not (string? message-16954))
               (syntax-violation
                 'syntax-violation
                 "invalid argument"
-                message-17125))
+                message-16954))
             (throw 'syntax-error
-                   who-17124
-                   message-17125
-                   (source-annotation-4544
-                     (if form-17126 form-17126 subform-17127))
-                   (strip-4599 form-17126 '(()))
-                   (if subform-17127
-                     (strip-4599 subform-17127 '(()))
+                   who-16953
+                   message-16954
+                   (let ((t-17005 (source-annotation-4340 subform-16956)))
+                     (if t-17005
+                       t-17005
+                       (source-annotation-4340 form-16955)))
+                   (strip-4395 form-16955 '(()))
+                   (if subform-16956
+                     (strip-4395 subform-16956 '(()))
                      #f)))))
       (letrec*
-        ((syntax-local-binding-17377
-           (lambda (id-17517)
+        ((syntax-local-binding-17469
+           (lambda (id-17609)
              (begin
-               (if (not (if (if (vector? id-17517)
-                              (if (= (vector-length id-17517) 4)
-                                (eq? (vector-ref id-17517 0) 'syntax-object)
+               (if (not (if (if (vector? id-17609)
+                              (if (= (vector-length id-17609) 4)
+                                (eq? (vector-ref id-17609 0) 'syntax-object)
                                 #f)
                               #f)
-                          (symbol? (vector-ref id-17517 1))
+                          (symbol? (vector-ref id-17609 1))
                           #f))
                  (syntax-violation
                    'syntax-local-binding
                    "invalid argument"
-                   id-17517))
-               ((fluid-ref transformer-environment-4572)
-                (lambda (e-17557
-                         r-17558
-                         w-17559
-                         s-17560
-                         rib-17561
-                         mod-17562)
+                   id-17609))
+               ((fluid-ref transformer-environment-4368)
+                (lambda (e-17649
+                         r-17650
+                         w-17651
+                         s-17652
+                         rib-17653
+                         mod-17654)
                   (call-with-values
                     (lambda ()
-                      (resolve-identifier-4571
-                        (vector-ref id-17517 1)
-                        (let ((w-17569 (vector-ref id-17517 2)))
-                          (let ((ms-17570 (car w-17569))
-                                (s-17571 (cdr w-17569)))
-                            (if (if (pair? ms-17570)
-                                  (eq? (car ms-17570) #f)
+                      (resolve-identifier-4367
+                        (vector-ref id-17609 1)
+                        (let ((w-17661 (vector-ref id-17609 2)))
+                          (let ((ms-17662 (car w-17661))
+                                (s-17663 (cdr w-17661)))
+                            (if (if (pair? ms-17662)
+                                  (eq? (car ms-17662) #f)
                                   #f)
-                              (cons (cdr ms-17570)
-                                    (if rib-17561
-                                      (cons rib-17561 (cdr s-17571))
-                                      (cdr s-17571)))
-                              (cons ms-17570
-                                    (if rib-17561
-                                      (cons rib-17561 s-17571)
-                                      s-17571)))))
-                        r-17558
-                        (vector-ref id-17517 3)
+                              (cons (cdr ms-17662)
+                                    (if rib-17653
+                                      (cons rib-17653 (cdr s-17663))
+                                      (cdr s-17663)))
+                              (cons ms-17662
+                                    (if rib-17653
+                                      (cons rib-17653 s-17663)
+                                      s-17663)))))
+                        r-17650
+                        (vector-ref id-17609 3)
                         #t))
-                    (lambda (type-17578 value-17579 mod-17580)
-                      (if (eqv? type-17578 'lexical)
-                        (values 'lexical value-17579)
-                        (if (eqv? type-17578 'macro)
-                          (values 'macro value-17579)
-                          (if (eqv? type-17578 'syntax)
-                            (values 'pattern-variable value-17579)
-                            (if (eqv? type-17578 'displaced-lexical)
+                    (lambda (type-17670 value-17671 mod-17672)
+                      (if (eqv? type-17670 'lexical)
+                        (values 'lexical value-17671)
+                        (if (eqv? type-17670 'macro)
+                          (values 'macro value-17671)
+                          (if (eqv? type-17670 'syntax)
+                            (values 'pattern-variable value-17671)
+                            (if (eqv? type-17670 'displaced-lexical)
                               (values 'displaced-lexical #f)
-                              (if (eqv? type-17578 'global)
+                              (if (eqv? type-17670 'global)
                                 (values
                                   'global
-                                  (cons value-17579 (cdr mod-17580)))
+                                  (cons value-17671 (cdr mod-17672)))
                                 (values 'other #f)))))))))))))
-         (syntax-locally-bound-identifiers-17378
-           (lambda (id-17591)
+         (syntax-locally-bound-identifiers-17470
+           (lambda (id-17694)
              (begin
-               (if (not (if (if (vector? id-17591)
-                              (if (= (vector-length id-17591) 4)
-                                (eq? (vector-ref id-17591 0) 'syntax-object)
+               (if (not (if (if (vector? id-17694)
+                              (if (= (vector-length id-17694) 4)
+                                (eq? (vector-ref id-17694 0) 'syntax-object)
                                 #f)
                               #f)
-                          (symbol? (vector-ref id-17591 1))
+                          (symbol? (vector-ref id-17694 1))
                           #f))
                  (syntax-violation
                    'syntax-locally-bound-identifiers
                    "invalid argument"
-                   id-17591))
-               (locally-bound-identifiers-4570
-                 (vector-ref id-17591 2)
-                 (vector-ref id-17591 3))))))
+                   id-17694))
+               (locally-bound-identifiers-4366
+                 (vector-ref id-17694 2)
+                 (vector-ref id-17694 3))))))
         (begin
           (define!
             'syntax-module
-            (lambda (id-17380)
+            (lambda (id-17472)
               (begin
-                (if (not (if (if (vector? id-17380)
-                               (if (= (vector-length id-17380) 4)
-                                 (eq? (vector-ref id-17380 0) 'syntax-object)
+                (if (not (if (if (vector? id-17472)
+                               (if (= (vector-length id-17472) 4)
+                                 (eq? (vector-ref id-17472 0) 'syntax-object)
                                  #f)
                                #f)
-                           (symbol? (vector-ref id-17380 1))
+                           (symbol? (vector-ref id-17472 1))
                            #f))
                   (syntax-violation
                     'syntax-module
                     "invalid argument"
-                    id-17380))
-                (cdr (vector-ref id-17380 3)))))
+                    id-17472))
+                (cdr (vector-ref id-17472 3)))))
           (define!
             'syntax-local-binding
-            syntax-local-binding-17377)
+            syntax-local-binding-17469)
           (define!
             'syntax-locally-bound-identifiers
-            syntax-locally-bound-identifiers-17378)))
+            syntax-locally-bound-identifiers-17470)))
       (letrec*
-        ((match-each-17708
-           (lambda (e-18587 p-18588 w-18589 mod-18590)
-             (if (pair? e-18587)
-               (let ((first-18591
-                       (match-17714
-                         (car e-18587)
-                         p-18588
-                         w-18589
+        ((match-each-17811
+           (lambda (e-18690 p-18691 w-18692 mod-18693)
+             (if (pair? e-18690)
+               (let ((first-18694
+                       (match-17817
+                         (car e-18690)
+                         p-18691
+                         w-18692
                          '()
-                         mod-18590)))
-                 (if first-18591
-                   (let ((rest-18594
-                           (match-each-17708
-                             (cdr e-18587)
-                             p-18588
-                             w-18589
-                             mod-18590)))
-                     (if rest-18594 (cons first-18591 rest-18594) #f))
+                         mod-18693)))
+                 (if first-18694
+                   (let ((rest-18697
+                           (match-each-17811
+                             (cdr e-18690)
+                             p-18691
+                             w-18692
+                             mod-18693)))
+                     (if rest-18697 (cons first-18694 rest-18697) #f))
                    #f))
-               (if (null? e-18587)
+               (if (null? e-18690)
                  '()
-                 (if (if (vector? e-18587)
-                       (if (= (vector-length e-18587) 4)
-                         (eq? (vector-ref e-18587 0) 'syntax-object)
+                 (if (if (vector? e-18690)
+                       (if (= (vector-length e-18690) 4)
+                         (eq? (vector-ref e-18690 0) 'syntax-object)
                          #f)
                        #f)
-                   (match-each-17708
-                     (vector-ref e-18587 1)
-                     p-18588
-                     (let ((w2-18616 (vector-ref e-18587 2)))
-                       (let ((m1-18617 (car w-18589))
-                             (s1-18618 (cdr w-18589)))
-                         (if (null? m1-18617)
-                           (if (null? s1-18618)
-                             w2-18616
-                             (cons (car w2-18616)
-                                   (let ((m2-18629 (cdr w2-18616)))
-                                     (if (null? m2-18629)
-                                       s1-18618
-                                       (append s1-18618 m2-18629)))))
-                           (cons (let ((m2-18637 (car w2-18616)))
-                                   (if (null? m2-18637)
-                                     m1-18617
-                                     (append m1-18617 m2-18637)))
-                                 (let ((m2-18645 (cdr w2-18616)))
-                                   (if (null? m2-18645)
-                                     s1-18618
-                                     (append s1-18618 m2-18645)))))))
-                     (vector-ref e-18587 3))
+                   (match-each-17811
+                     (vector-ref e-18690 1)
+                     p-18691
+                     (let ((w2-18719 (vector-ref e-18690 2)))
+                       (let ((m1-18720 (car w-18692))
+                             (s1-18721 (cdr w-18692)))
+                         (if (null? m1-18720)
+                           (if (null? s1-18721)
+                             w2-18719
+                             (cons (car w2-18719)
+                                   (let ((m2-18732 (cdr w2-18719)))
+                                     (if (null? m2-18732)
+                                       s1-18721
+                                       (append s1-18721 m2-18732)))))
+                           (cons (let ((m2-18740 (car w2-18719)))
+                                   (if (null? m2-18740)
+                                     m1-18720
+                                     (append m1-18720 m2-18740)))
+                                 (let ((m2-18748 (cdr w2-18719)))
+                                   (if (null? m2-18748)
+                                     s1-18721
+                                     (append s1-18721 m2-18748)))))))
+                     (vector-ref e-18690 3))
                    #f)))))
-         (match-each-any-17710
-           (lambda (e-18654 w-18655 mod-18656)
-             (if (pair? e-18654)
-               (let ((l-18657
-                       (match-each-any-17710
-                         (cdr e-18654)
-                         w-18655
-                         mod-18656)))
-                 (if l-18657
-                   (cons (let ((x-18662 (car e-18654)))
-                           (if (if (null? (car w-18655))
-                                 (null? (cdr w-18655))
+         (match-each-any-17813
+           (lambda (e-18757 w-18758 mod-18759)
+             (if (pair? e-18757)
+               (let ((l-18760
+                       (match-each-any-17813
+                         (cdr e-18757)
+                         w-18758
+                         mod-18759)))
+                 (if l-18760
+                   (cons (let ((x-18765 (car e-18757)))
+                           (if (if (null? (car w-18758))
+                                 (null? (cdr w-18758))
                                  #f)
-                             x-18662
-                             (if (if (vector? x-18662)
-                                   (if (= (vector-length x-18662) 4)
-                                     (eq? (vector-ref x-18662 0)
+                             x-18765
+                             (if (if (vector? x-18765)
+                                   (if (= (vector-length x-18765) 4)
+                                     (eq? (vector-ref x-18765 0)
                                           'syntax-object)
                                      #f)
                                    #f)
-                               (let ((expression-18680 (vector-ref x-18662 1))
-                                     (wrap-18681
-                                       (let ((w2-18689 (vector-ref x-18662 2)))
-                                         (let ((m1-18690 (car w-18655))
-                                               (s1-18691 (cdr w-18655)))
-                                           (if (null? m1-18690)
-                                             (if (null? s1-18691)
-                                               w2-18689
-                                               (cons (car w2-18689)
-                                                     (let ((m2-18706
-                                                             (cdr w2-18689)))
-                                                       (if (null? m2-18706)
-                                                         s1-18691
+                               (let ((expression-18783 (vector-ref x-18765 1))
+                                     (wrap-18784
+                                       (let ((w2-18792 (vector-ref x-18765 2)))
+                                         (let ((m1-18793 (car w-18758))
+                                               (s1-18794 (cdr w-18758)))
+                                           (if (null? m1-18793)
+                                             (if (null? s1-18794)
+                                               w2-18792
+                                               (cons (car w2-18792)
+                                                     (let ((m2-18809
+                                                             (cdr w2-18792)))
+                                                       (if (null? m2-18809)
+                                                         s1-18794
                                                          (append
-                                                           s1-18691
-                                                           m2-18706)))))
-                                             (cons (let ((m2-18714
-                                                           (car w2-18689)))
-                                                     (if (null? m2-18714)
-                                                       m1-18690
+                                                           s1-18794
+                                                           m2-18809)))))
+                                             (cons (let ((m2-18817
+                                                           (car w2-18792)))
+                                                     (if (null? m2-18817)
+                                                       m1-18793
                                                        (append
-                                                         m1-18690
-                                                         m2-18714)))
-                                                   (let ((m2-18722
-                                                           (cdr w2-18689)))
-                                                     (if (null? m2-18722)
-                                                       s1-18691
+                                                         m1-18793
+                                                         m2-18817)))
+                                                   (let ((m2-18825
+                                                           (cdr w2-18792)))
+                                                     (if (null? m2-18825)
+                                                       s1-18794
                                                        (append
-                                                         s1-18691
-                                                         m2-18722))))))))
-                                     (module-18682 (vector-ref x-18662 3)))
+                                                         s1-18794
+                                                         m2-18825))))))))
+                                     (module-18785 (vector-ref x-18765 3)))
                                  (vector
                                    'syntax-object
-                                   expression-18680
-                                   wrap-18681
-                                   module-18682))
-                               (if (null? x-18662)
-                                 x-18662
+                                   expression-18783
+                                   wrap-18784
+                                   module-18785))
+                               (if (null? x-18765)
+                                 x-18765
                                  (vector
                                    'syntax-object
-                                   x-18662
-                                   w-18655
-                                   mod-18656)))))
-                         l-18657)
+                                   x-18765
+                                   w-18758
+                                   mod-18759)))))
+                         l-18760)
                    #f))
-               (if (null? e-18654)
+               (if (null? e-18757)
                  '()
-                 (if (if (vector? e-18654)
-                       (if (= (vector-length e-18654) 4)
-                         (eq? (vector-ref e-18654 0) 'syntax-object)
+                 (if (if (vector? e-18757)
+                       (if (= (vector-length e-18757) 4)
+                         (eq? (vector-ref e-18757 0) 'syntax-object)
                          #f)
                        #f)
-                   (match-each-any-17710
-                     (vector-ref e-18654 1)
-                     (let ((w2-18755 (vector-ref e-18654 2)))
-                       (let ((m1-18756 (car w-18655))
-                             (s1-18757 (cdr w-18655)))
-                         (if (null? m1-18756)
-                           (if (null? s1-18757)
-                             w2-18755
-                             (cons (car w2-18755)
-                                   (let ((m2-18768 (cdr w2-18755)))
-                                     (if (null? m2-18768)
-                                       s1-18757
-                                       (append s1-18757 m2-18768)))))
-                           (cons (let ((m2-18776 (car w2-18755)))
-                                   (if (null? m2-18776)
-                                     m1-18756
-                                     (append m1-18756 m2-18776)))
-                                 (let ((m2-18784 (cdr w2-18755)))
-                                   (if (null? m2-18784)
-                                     s1-18757
-                                     (append s1-18757 m2-18784)))))))
-                     mod-18656)
+                   (match-each-any-17813
+                     (vector-ref e-18757 1)
+                     (let ((w2-18858 (vector-ref e-18757 2)))
+                       (let ((m1-18859 (car w-18758))
+                             (s1-18860 (cdr w-18758)))
+                         (if (null? m1-18859)
+                           (if (null? s1-18860)
+                             w2-18858
+                             (cons (car w2-18858)
+                                   (let ((m2-18871 (cdr w2-18858)))
+                                     (if (null? m2-18871)
+                                       s1-18860
+                                       (append s1-18860 m2-18871)))))
+                           (cons (let ((m2-18879 (car w2-18858)))
+                                   (if (null? m2-18879)
+                                     m1-18859
+                                     (append m1-18859 m2-18879)))
+                                 (let ((m2-18887 (cdr w2-18858)))
+                                   (if (null? m2-18887)
+                                     s1-18860
+                                     (append s1-18860 m2-18887)))))))
+                     mod-18759)
                    #f)))))
-         (match-empty-17711
-           (lambda (p-18789 r-18790)
-             (if (null? p-18789)
-               r-18790
-               (if (eq? p-18789 '_)
-                 r-18790
-                 (if (eq? p-18789 'any)
-                   (cons '() r-18790)
-                   (if (pair? p-18789)
-                     (match-empty-17711
-                       (car p-18789)
-                       (match-empty-17711 (cdr p-18789) r-18790))
-                     (if (eq? p-18789 'each-any)
-                       (cons '() r-18790)
-                       (let ((atom-key-18791 (vector-ref p-18789 0)))
-                         (if (eqv? atom-key-18791 'each)
-                           (match-empty-17711
-                             (vector-ref p-18789 1)
-                             r-18790)
-                           (if (eqv? atom-key-18791 'each+)
-                             (match-empty-17711
-                               (vector-ref p-18789 1)
-                               (match-empty-17711
-                                 (reverse (vector-ref p-18789 2))
-                                 (match-empty-17711
-                                   (vector-ref p-18789 3)
-                                   r-18790)))
-                             (if (if (eqv? atom-key-18791 'free-id)
+         (match-empty-17814
+           (lambda (p-18892 r-18893)
+             (if (null? p-18892)
+               r-18893
+               (if (eq? p-18892 '_)
+                 r-18893
+                 (if (eq? p-18892 'any)
+                   (cons '() r-18893)
+                   (if (pair? p-18892)
+                     (match-empty-17814
+                       (car p-18892)
+                       (match-empty-17814 (cdr p-18892) r-18893))
+                     (if (eq? p-18892 'each-any)
+                       (cons '() r-18893)
+                       (let ((key-18894 (vector-ref p-18892 0)))
+                         (if (eqv? key-18894 'each)
+                           (match-empty-17814
+                             (vector-ref p-18892 1)
+                             r-18893)
+                           (if (eqv? key-18894 'each+)
+                             (match-empty-17814
+                               (vector-ref p-18892 1)
+                               (match-empty-17814
+                                 (reverse (vector-ref p-18892 2))
+                                 (match-empty-17814
+                                   (vector-ref p-18892 3)
+                                   r-18893)))
+                             (if (if (eqv? key-18894 'free-id)
                                    #t
-                                   (eqv? atom-key-18791 'atom))
-                               r-18790
-                               (if (eqv? atom-key-18791 'vector)
-                                 (match-empty-17711
-                                   (vector-ref p-18789 1)
-                                   r-18790)))))))))))))
-         (combine-17712
-           (lambda (r*-18810 r-18811)
-             (if (null? (car r*-18810))
-               r-18811
-               (cons (map car r*-18810)
-                     (combine-17712 (map cdr r*-18810) r-18811)))))
-         (match*-17713
-           (lambda (e-17743 p-17744 w-17745 r-17746 mod-17747)
-             (if (null? p-17744)
-               (if (null? e-17743) r-17746 #f)
-               (if (pair? p-17744)
-                 (if (pair? e-17743)
-                   (match-17714
-                     (car e-17743)
-                     (car p-17744)
-                     w-17745
-                     (match-17714
-                       (cdr e-17743)
-                       (cdr p-17744)
-                       w-17745
-                       r-17746
-                       mod-17747)
-                     mod-17747)
+                                   (eqv? key-18894 'atom))
+                               r-18893
+                               (if (eqv? key-18894 'vector)
+                                 (match-empty-17814
+                                   (vector-ref p-18892 1)
+                                   r-18893)))))))))))))
+         (combine-17815
+           (lambda (r*-18913 r-18914)
+             (if (null? (car r*-18913))
+               r-18914
+               (cons (map car r*-18913)
+                     (combine-17815 (map cdr r*-18913) r-18914)))))
+         (match*-17816
+           (lambda (e-17846 p-17847 w-17848 r-17849 mod-17850)
+             (if (null? p-17847)
+               (if (null? e-17846) r-17849 #f)
+               (if (pair? p-17847)
+                 (if (pair? e-17846)
+                   (match-17817
+                     (car e-17846)
+                     (car p-17847)
+                     w-17848
+                     (match-17817
+                       (cdr e-17846)
+                       (cdr p-17847)
+                       w-17848
+                       r-17849
+                       mod-17850)
+                     mod-17850)
                    #f)
-                 (if (eq? p-17744 'each-any)
-                   (let ((l-17752
-                           (match-each-any-17710 e-17743 w-17745 mod-17747)))
-                     (if l-17752 (cons l-17752 r-17746) #f))
-                   (let ((atom-key-17757 (vector-ref p-17744 0)))
-                     (if (eqv? atom-key-17757 'each)
-                       (if (null? e-17743)
-                         (match-empty-17711
-                           (vector-ref p-17744 1)
-                           r-17746)
-                         (let ((l-17764
-                                 (match-each-17708
-                                   e-17743
-                                   (vector-ref p-17744 1)
-                                   w-17745
-                                   mod-17747)))
-                           (if l-17764
+                 (if (eq? p-17847 'each-any)
+                   (let ((l-17855
+                           (match-each-any-17813 e-17846 w-17848 mod-17850)))
+                     (if l-17855 (cons l-17855 r-17849) #f))
+                   (let ((key-17860 (vector-ref p-17847 0)))
+                     (if (eqv? key-17860 'each)
+                       (if (null? e-17846)
+                         (match-empty-17814
+                           (vector-ref p-17847 1)
+                           r-17849)
+                         (let ((l-17867
+                                 (match-each-17811
+                                   e-17846
+                                   (vector-ref p-17847 1)
+                                   w-17848
+                                   mod-17850)))
+                           (if l-17867
                              (letrec*
-                               ((collect-17767
-                                  (lambda (l-17824)
-                                    (if (null? (car l-17824))
-                                      r-17746
-                                      (cons (map car l-17824)
-                                            (collect-17767
-                                              (map cdr l-17824)))))))
-                               (collect-17767 l-17764))
+                               ((collect-17870
+                                  (lambda (l-17927)
+                                    (if (null? (car l-17927))
+                                      r-17849
+                                      (cons (map car l-17927)
+                                            (collect-17870
+                                              (map cdr l-17927)))))))
+                               (collect-17870 l-17867))
                              #f)))
-                       (if (eqv? atom-key-17757 'each+)
+                       (if (eqv? key-17860 'each+)
                          (call-with-values
                            (lambda ()
-                             (let ((x-pat-17833 (vector-ref p-17744 1))
-                                   (y-pat-17834 (vector-ref p-17744 2))
-                                   (z-pat-17835 (vector-ref p-17744 3)))
+                             (let ((x-pat-17936 (vector-ref p-17847 1))
+                                   (y-pat-17937 (vector-ref p-17847 2))
+                                   (z-pat-17938 (vector-ref p-17847 3)))
                                (letrec*
-                                 ((f-17839
-                                    (lambda (e-17841 w-17842)
-                                      (if (pair? e-17841)
+                                 ((f-17942
+                                    (lambda (e-17944 w-17945)
+                                      (if (pair? e-17944)
                                         (call-with-values
                                           (lambda ()
-                                            (f-17839 (cdr e-17841) w-17842))
-                                          (lambda (xr*-17843
-                                                   y-pat-17844
-                                                   r-17845)
-                                            (if r-17845
-                                              (if (null? y-pat-17844)
-                                                (let ((xr-17846
-                                                        (match-17714
-                                                          (car e-17841)
-                                                          x-pat-17833
-                                                          w-17842
+                                            (f-17942 (cdr e-17944) w-17945))
+                                          (lambda (xr*-17946
+                                                   y-pat-17947
+                                                   r-17948)
+                                            (if r-17948
+                                              (if (null? y-pat-17947)
+                                                (let ((xr-17949
+                                                        (match-17817
+                                                          (car e-17944)
+                                                          x-pat-17936
+                                                          w-17945
                                                           '()
-                                                          mod-17747)))
-                                                  (if xr-17846
+                                                          mod-17850)))
+                                                  (if xr-17949
                                                     (values
-                                                      (cons xr-17846 xr*-17843)
-                                                      y-pat-17844
-                                                      r-17845)
+                                                      (cons xr-17949 xr*-17946)
+                                                      y-pat-17947
+                                                      r-17948)
                                                     (values #f #f #f)))
                                                 (values
                                                   '()
-                                                  (cdr y-pat-17844)
-                                                  (match-17714
-                                                    (car e-17841)
-                                                    (car y-pat-17844)
-                                                    w-17842
-                                                    r-17845
-                                                    mod-17747)))
+                                                  (cdr y-pat-17947)
+                                                  (match-17817
+                                                    (car e-17944)
+                                                    (car y-pat-17947)
+                                                    w-17945
+                                                    r-17948
+                                                    mod-17850)))
                                               (values #f #f #f))))
-                                        (if (if (vector? e-17841)
-                                              (if (= (vector-length e-17841) 4)
-                                                (eq? (vector-ref e-17841 0)
+                                        (if (if (vector? e-17944)
+                                              (if (= (vector-length e-17944) 4)
+                                                (eq? (vector-ref e-17944 0)
                                                      'syntax-object)
                                                 #f)
                                               #f)
-                                          (f-17839
-                                            (vector-ref e-17841 1)
-                                            (let ((m1-17872 (car w-17842))
-                                                  (s1-17873 (cdr w-17842)))
-                                              (if (null? m1-17872)
-                                                (if (null? s1-17873)
-                                                  e-17841
-                                                  (cons (car e-17841)
-                                                        (let ((m2-17885
-                                                                (cdr e-17841)))
-                                                          (if (null? m2-17885)
-                                                            s1-17873
+                                          (f-17942
+                                            (vector-ref e-17944 1)
+                                            (let ((m1-17975 (car w-17945))
+                                                  (s1-17976 (cdr w-17945)))
+                                              (if (null? m1-17975)
+                                                (if (null? s1-17976)
+                                                  e-17944
+                                                  (cons (car e-17944)
+                                                        (let ((m2-17988
+                                                                (cdr e-17944)))
+                                                          (if (null? m2-17988)
+                                                            s1-17976
                                                             (append
-                                                              s1-17873
-                                                              m2-17885)))))
-                                                (cons (let ((m2-17895
-                                                              (car e-17841)))
-                                                        (if (null? m2-17895)
-                                                          m1-17872
+                                                              s1-17976
+                                                              m2-17988)))))
+                                                (cons (let ((m2-17998
+                                                              (car e-17944)))
+                                                        (if (null? m2-17998)
+                                                          m1-17975
                                                           (append
-                                                            m1-17872
-                                                            m2-17895)))
-                                                      (let ((m2-17905
-                                                              (cdr e-17841)))
-                                                        (if (null? m2-17905)
-                                                          s1-17873
+                                                            m1-17975
+                                                            m2-17998)))
+                                                      (let ((m2-18008
+                                                              (cdr e-17944)))
+                                                        (if (null? m2-18008)
+                                                          s1-17976
                                                           (append
-                                                            s1-17873
-                                                            m2-17905)))))))
+                                                            s1-17976
+                                                            m2-18008)))))))
                                           (values
                                             '()
-                                            y-pat-17834
-                                            (match-17714
-                                              e-17841
-                                              z-pat-17835
-                                              w-17842
-                                              r-17746
-                                              mod-17747)))))))
-                                 (f-17839 e-17743 w-17745))))
-                           (lambda (xr*-17915 y-pat-17916 r-17917)
-                             (if r-17917
-                               (if (null? y-pat-17916)
-                                 (if (null? xr*-17915)
-                                   (match-empty-17711
-                                     (vector-ref p-17744 1)
-                                     r-17917)
-                                   (combine-17712 xr*-17915 r-17917))
+                                            y-pat-17937
+                                            (match-17817
+                                              e-17944
+                                              z-pat-17938
+                                              w-17945
+                                              r-17849
+                                              mod-17850)))))))
+                                 (f-17942 e-17846 w-17848))))
+                           (lambda (xr*-18018 y-pat-18019 r-18020)
+                             (if r-18020
+                               (if (null? y-pat-18019)
+                                 (if (null? xr*-18018)
+                                   (match-empty-17814
+                                     (vector-ref p-17847 1)
+                                     r-18020)
+                                   (combine-17815 xr*-18018 r-18020))
                                  #f)
                                #f)))
-                         (if (eqv? atom-key-17757 'free-id)
-                           (if (if (symbol? e-17743)
+                         (if (eqv? key-17860 'free-id)
+                           (if (if (symbol? e-17846)
                                  #t
-                                 (if (if (vector? e-17743)
-                                       (if (= (vector-length e-17743) 4)
-                                         (eq? (vector-ref e-17743 0)
+                                 (if (if (vector? e-17846)
+                                       (if (= (vector-length e-17846) 4)
+                                         (eq? (vector-ref e-17846 0)
                                               'syntax-object)
                                          #f)
                                        #f)
-                                   (symbol? (vector-ref e-17743 1))
+                                   (symbol? (vector-ref e-17846 1))
                                    #f))
-                             (if (free-id=?-4574
-                                   (if (if (null? (car w-17745))
-                                         (null? (cdr w-17745))
+                             (if (free-id=?-4370
+                                   (if (if (null? (car w-17848))
+                                         (null? (cdr w-17848))
                                          #f)
-                                     e-17743
-                                     (if (if (vector? e-17743)
-                                           (if (= (vector-length e-17743) 4)
-                                             (eq? (vector-ref e-17743 0)
+                                     e-17846
+                                     (if (if (vector? e-17846)
+                                           (if (= (vector-length e-17846) 4)
+                                             (eq? (vector-ref e-17846 0)
                                                   'syntax-object)
                                              #f)
                                            #f)
-                                       (let ((expression-18345
-                                               (vector-ref e-17743 1))
-                                             (wrap-18346
-                                               (let ((w2-18356
-                                                       (vector-ref e-17743 2)))
-                                                 (let ((m1-18357 (car w-17745))
-                                                       (s1-18358
-                                                         (cdr w-17745)))
-                                                   (if (null? m1-18357)
-                                                     (if (null? s1-18358)
-                                                       w2-18356
-                                                       (cons (car w2-18356)
-                                                             (let ((m2-18375
-                                                                     (cdr 
w2-18356)))
-                                                               (if (null? 
m2-18375)
-                                                                 s1-18358
+                                       (let ((expression-18448
+                                               (vector-ref e-17846 1))
+                                             (wrap-18449
+                                               (let ((w2-18459
+                                                       (vector-ref e-17846 2)))
+                                                 (let ((m1-18460 (car w-17848))
+                                                       (s1-18461
+                                                         (cdr w-17848)))
+                                                   (if (null? m1-18460)
+                                                     (if (null? s1-18461)
+                                                       w2-18459
+                                                       (cons (car w2-18459)
+                                                             (let ((m2-18478
+                                                                     (cdr 
w2-18459)))
+                                                               (if (null? 
m2-18478)
+                                                                 s1-18461
                                                                  (append
-                                                                   s1-18358
-                                                                   
m2-18375)))))
-                                                     (cons (let ((m2-18383
-                                                                   (car 
w2-18356)))
-                                                             (if (null? 
m2-18383)
-                                                               m1-18357
+                                                                   s1-18461
+                                                                   
m2-18478)))))
+                                                     (cons (let ((m2-18486
+                                                                   (car 
w2-18459)))
+                                                             (if (null? 
m2-18486)
+                                                               m1-18460
                                                                (append
-                                                                 m1-18357
-                                                                 m2-18383)))
-                                                           (let ((m2-18391
-                                                                   (cdr 
w2-18356)))
-                                                             (if (null? 
m2-18391)
-                                                               s1-18358
+                                                                 m1-18460
+                                                                 m2-18486)))
+                                                           (let ((m2-18494
+                                                                   (cdr 
w2-18459)))
+                                                             (if (null? 
m2-18494)
+                                                               s1-18461
                                                                (append
-                                                                 s1-18358
-                                                                 
m2-18391))))))))
-                                             (module-18347
-                                               (vector-ref e-17743 3)))
+                                                                 s1-18461
+                                                                 
m2-18494))))))))
+                                             (module-18450
+                                               (vector-ref e-17846 3)))
                                          (vector
                                            'syntax-object
-                                           expression-18345
-                                           wrap-18346
-                                           module-18347))
-                                       (if (null? e-17743)
-                                         e-17743
+                                           expression-18448
+                                           wrap-18449
+                                           module-18450))
+                                       (if (null? e-17846)
+                                         e-17846
                                          (vector
                                            'syntax-object
-                                           e-17743
-                                           w-17745
-                                           mod-17747))))
-                                   (vector-ref p-17744 1))
-                               r-17746
+                                           e-17846
+                                           w-17848
+                                           mod-17850))))
+                                   (vector-ref p-17847 1))
+                               r-17849
                                #f)
                              #f)
-                           (if (eqv? atom-key-17757 'atom)
+                           (if (eqv? key-17860 'atom)
                              (if (equal?
-                                   (vector-ref p-17744 1)
-                                   (strip-4599 e-17743 w-17745))
-                               r-17746
+                                   (vector-ref p-17847 1)
+                                   (strip-4395 e-17846 w-17848))
+                               r-17849
                                #f)
-                             (if (eqv? atom-key-17757 'vector)
-                               (if (vector? e-17743)
-                                 (match-17714
-                                   (vector->list e-17743)
-                                   (vector-ref p-17744 1)
-                                   w-17745
-                                   r-17746
-                                   mod-17747)
+                             (if (eqv? key-17860 'vector)
+                               (if (vector? e-17846)
+                                 (match-17817
+                                   (vector->list e-17846)
+                                   (vector-ref p-17847 1)
+                                   w-17848
+                                   r-17849
+                                   mod-17850)
                                  #f))))))))))))
-         (match-17714
-           (lambda (e-18424 p-18425 w-18426 r-18427 mod-18428)
-             (if (not r-18427)
+         (match-17817
+           (lambda (e-18527 p-18528 w-18529 r-18530 mod-18531)
+             (if (not r-18530)
                #f
-               (if (eq? p-18425 '_)
-                 r-18427
-                 (if (eq? p-18425 'any)
-                   (cons (if (if (null? (car w-18426))
-                               (null? (cdr w-18426))
+               (if (eq? p-18528 '_)
+                 r-18530
+                 (if (eq? p-18528 'any)
+                   (cons (if (if (null? (car w-18529))
+                               (null? (cdr w-18529))
                                #f)
-                           e-18424
-                           (if (if (vector? e-18424)
-                                 (if (= (vector-length e-18424) 4)
-                                   (eq? (vector-ref e-18424 0) 'syntax-object)
+                           e-18527
+                           (if (if (vector? e-18527)
+                                 (if (= (vector-length e-18527) 4)
+                                   (eq? (vector-ref e-18527 0) 'syntax-object)
                                    #f)
                                  #f)
-                             (let ((expression-18458 (vector-ref e-18424 1))
-                                   (wrap-18459
-                                     (let ((w2-18469 (vector-ref e-18424 2)))
-                                       (let ((m1-18470 (car w-18426))
-                                             (s1-18471 (cdr w-18426)))
-                                         (if (null? m1-18470)
-                                           (if (null? s1-18471)
-                                             w2-18469
-                                             (cons (car w2-18469)
-                                                   (let ((m2-18488
-                                                           (cdr w2-18469)))
-                                                     (if (null? m2-18488)
-                                                       s1-18471
+                             (let ((expression-18561 (vector-ref e-18527 1))
+                                   (wrap-18562
+                                     (let ((w2-18572 (vector-ref e-18527 2)))
+                                       (let ((m1-18573 (car w-18529))
+                                             (s1-18574 (cdr w-18529)))
+                                         (if (null? m1-18573)
+                                           (if (null? s1-18574)
+                                             w2-18572
+                                             (cons (car w2-18572)
+                                                   (let ((m2-18591
+                                                           (cdr w2-18572)))
+                                                     (if (null? m2-18591)
+                                                       s1-18574
                                                        (append
-                                                         s1-18471
-                                                         m2-18488)))))
-                                           (cons (let ((m2-18496
-                                                         (car w2-18469)))
-                                                   (if (null? m2-18496)
-                                                     m1-18470
+                                                         s1-18574
+                                                         m2-18591)))))
+                                           (cons (let ((m2-18599
+                                                         (car w2-18572)))
+                                                   (if (null? m2-18599)
+                                                     m1-18573
                                                      (append
-                                                       m1-18470
-                                                       m2-18496)))
-                                                 (let ((m2-18504
-                                                         (cdr w2-18469)))
-                                                   (if (null? m2-18504)
-                                                     s1-18471
+                                                       m1-18573
+                                                       m2-18599)))
+                                                 (let ((m2-18607
+                                                         (cdr w2-18572)))
+                                                   (if (null? m2-18607)
+                                                     s1-18574
                                                      (append
-                                                       s1-18471
-                                                       m2-18504))))))))
-                                   (module-18460 (vector-ref e-18424 3)))
+                                                       s1-18574
+                                                       m2-18607))))))))
+                                   (module-18563 (vector-ref e-18527 3)))
                                (vector
                                  'syntax-object
-                                 expression-18458
-                                 wrap-18459
-                                 module-18460))
-                             (if (null? e-18424)
-                               e-18424
+                                 expression-18561
+                                 wrap-18562
+                                 module-18563))
+                             (if (null? e-18527)
+                               e-18527
                                (vector
                                  'syntax-object
-                                 e-18424
-                                 w-18426
-                                 mod-18428))))
-                         r-18427)
-                   (if (if (vector? e-18424)
-                         (if (= (vector-length e-18424) 4)
-                           (eq? (vector-ref e-18424 0) 'syntax-object)
+                                 e-18527
+                                 w-18529
+                                 mod-18531))))
+                         r-18530)
+                   (if (if (vector? e-18527)
+                         (if (= (vector-length e-18527) 4)
+                           (eq? (vector-ref e-18527 0) 'syntax-object)
                            #f)
                          #f)
-                     (match*-17713
-                       (vector-ref e-18424 1)
-                       p-18425
-                       (let ((w2-18547 (vector-ref e-18424 2)))
-                         (let ((m1-18548 (car w-18426))
-                               (s1-18549 (cdr w-18426)))
-                           (if (null? m1-18548)
-                             (if (null? s1-18549)
-                               w2-18547
-                               (cons (car w2-18547)
-                                     (let ((m2-18560 (cdr w2-18547)))
-                                       (if (null? m2-18560)
-                                         s1-18549
-                                         (append s1-18549 m2-18560)))))
-                             (cons (let ((m2-18568 (car w2-18547)))
-                                     (if (null? m2-18568)
-                                       m1-18548
-                                       (append m1-18548 m2-18568)))
-                                   (let ((m2-18576 (cdr w2-18547)))
-                                     (if (null? m2-18576)
-                                       s1-18549
-                                       (append s1-18549 m2-18576)))))))
-                       r-18427
-                       (vector-ref e-18424 3))
-                     (match*-17713
-                       e-18424
-                       p-18425
-                       w-18426
-                       r-18427
-                       mod-18428))))))))
+                     (match*-17816
+                       (vector-ref e-18527 1)
+                       p-18528
+                       (let ((w2-18650 (vector-ref e-18527 2)))
+                         (let ((m1-18651 (car w-18529))
+                               (s1-18652 (cdr w-18529)))
+                           (if (null? m1-18651)
+                             (if (null? s1-18652)
+                               w2-18650
+                               (cons (car w2-18650)
+                                     (let ((m2-18663 (cdr w2-18650)))
+                                       (if (null? m2-18663)
+                                         s1-18652
+                                         (append s1-18652 m2-18663)))))
+                             (cons (let ((m2-18671 (car w2-18650)))
+                                     (if (null? m2-18671)
+                                       m1-18651
+                                       (append m1-18651 m2-18671)))
+                                   (let ((m2-18679 (cdr w2-18650)))
+                                     (if (null? m2-18679)
+                                       s1-18652
+                                       (append s1-18652 m2-18679)))))))
+                       r-18530
+                       (vector-ref e-18527 3))
+                     (match*-17816
+                       e-18527
+                       p-18528
+                       w-18529
+                       r-18530
+                       mod-18531))))))))
         (set! $sc-dispatch
-          (lambda (e-17715 p-17716)
-            (if (eq? p-17716 'any)
-              (list e-17715)
-              (if (eq? p-17716 '_)
+          (lambda (e-17818 p-17819)
+            (if (eq? p-17819 'any)
+              (list e-17818)
+              (if (eq? p-17819 '_)
                 '()
-                (if (if (vector? e-17715)
-                      (if (= (vector-length e-17715) 4)
-                        (eq? (vector-ref e-17715 0) 'syntax-object)
+                (if (if (vector? e-17818)
+                      (if (= (vector-length e-17818) 4)
+                        (eq? (vector-ref e-17818 0) 'syntax-object)
                         #f)
                       #f)
-                  (match*-17713
-                    (vector-ref e-17715 1)
-                    p-17716
-                    (vector-ref e-17715 2)
+                  (match*-17816
+                    (vector-ref e-17818 1)
+                    p-17819
+                    (vector-ref e-17818 2)
                     '()
-                    (vector-ref e-17715 3))
-                  (match*-17713 e-17715 p-17716 '(()) '() #f))))))))))
+                    (vector-ref e-17818 3))
+                  (match*-17816 e-17818 p-17819 '(()) '() #f))))))))))
 
 (define with-syntax
   (make-syntax-transformer
     'with-syntax
     'macro
-    (lambda (x-37252)
-      (let ((tmp-37254
-              ($sc-dispatch x-37252 '(_ () any . each-any))))
-        (if tmp-37254
+    (lambda (x-37487)
+      (let ((tmp-37489
+              ($sc-dispatch x-37487 '(_ () any . each-any))))
+        (if tmp-37489
           (@apply
-            (lambda (e1-37258 e2-37259)
+            (lambda (e1-37493 e2-37494)
               (cons '#(syntax-object
                        let
                        ((top)
                         #(ribcage
                           #(e1 e2)
                           #((top) (top))
-                          #("l-*-37225" "l-*-37226"))
+                          #("l-*-37460" "l-*-37461"))
                         #(ribcage () () ())
-                        #(ribcage #(x) #((top)) #("l-*-37222"))
+                        #(ribcage #(x) #((top)) #("l-*-37457"))
                         #(ribcage
                           (with-syntax)
                           ((top))
@@ -17884,27 +17904,27 @@
                               ((top))
                               (hygiene guile))))))
                        (hygiene guile))
-                    (cons '() (cons e1-37258 e2-37259))))
-            tmp-37254)
-          (let ((tmp-37260
+                    (cons '() (cons e1-37493 e2-37494))))
+            tmp-37489)
+          (let ((tmp-37495
                   ($sc-dispatch
-                    x-37252
+                    x-37487
                     '(_ ((any any)) any . each-any))))
-            (if tmp-37260
+            (if tmp-37495
               (@apply
-                (lambda (out-37264 in-37265 e1-37266 e2-37267)
+                (lambda (out-37499 in-37500 e1-37501 e2-37502)
                   (list '#(syntax-object
                            syntax-case
                            ((top)
                             #(ribcage
                               #(out in e1 e2)
                               #((top) (top) (top) (top))
-                              #("l-*-37231"
-                                "l-*-37232"
-                                "l-*-37233"
-                                "l-*-37234"))
+                              #("l-*-37466"
+                                "l-*-37467"
+                                "l-*-37468"
+                                "l-*-37469"))
                             #(ribcage () () ())
-                            #(ribcage #(x) #((top)) #("l-*-37222"))
+                            #(ribcage #(x) #((top)) #("l-*-37457"))
                             #(ribcage
                               (with-syntax)
                               ((top))
@@ -17915,21 +17935,21 @@
                                   ((top))
                                   (hygiene guile))))))
                            (hygiene guile))
-                        in-37265
+                        in-37500
                         '()
-                        (list out-37264
+                        (list out-37499
                               (cons '#(syntax-object
                                        let
                                        ((top)
                                         #(ribcage
                                           #(out in e1 e2)
                                           #((top) (top) (top) (top))
-                                          #("l-*-37231"
-                                            "l-*-37232"
-                                            "l-*-37233"
-                                            "l-*-37234"))
+                                          #("l-*-37466"
+                                            "l-*-37467"
+                                            "l-*-37468"
+                                            "l-*-37469"))
                                         #(ribcage () () ())
-                                        #(ribcage #(x) #((top)) #("l-*-37222"))
+                                        #(ribcage #(x) #((top)) #("l-*-37457"))
                                         #(ribcage
                                           (with-syntax)
                                           ((top))
@@ -17940,27 +17960,27 @@
                                               ((top))
                                               (hygiene guile))))))
                                        (hygiene guile))
-                                    (cons '() (cons e1-37266 e2-37267))))))
-                tmp-37260)
-              (let ((tmp-37268
+                                    (cons '() (cons e1-37501 e2-37502))))))
+                tmp-37495)
+              (let ((tmp-37503
                       ($sc-dispatch
-                        x-37252
+                        x-37487
                         '(_ #(each (any any)) any . each-any))))
-                (if tmp-37268
+                (if tmp-37503
                   (@apply
-                    (lambda (out-37272 in-37273 e1-37274 e2-37275)
+                    (lambda (out-37507 in-37508 e1-37509 e2-37510)
                       (list '#(syntax-object
                                syntax-case
                                ((top)
                                 #(ribcage
                                   #(out in e1 e2)
                                   #((top) (top) (top) (top))
-                                  #("l-*-37241"
-                                    "l-*-37242"
-                                    "l-*-37243"
-                                    "l-*-37244"))
+                                  #("l-*-37476"
+                                    "l-*-37477"
+                                    "l-*-37478"
+                                    "l-*-37479"))
                                 #(ribcage () () ())
-                                #(ribcage #(x) #((top)) #("l-*-37222"))
+                                #(ribcage #(x) #((top)) #("l-*-37457"))
                                 #(ribcage
                                   (with-syntax)
                                   ((top))
@@ -17977,12 +17997,12 @@
                                       #(ribcage
                                         #(out in e1 e2)
                                         #((top) (top) (top) (top))
-                                        #("l-*-37241"
-                                          "l-*-37242"
-                                          "l-*-37243"
-                                          "l-*-37244"))
+                                        #("l-*-37476"
+                                          "l-*-37477"
+                                          "l-*-37478"
+                                          "l-*-37479"))
                                       #(ribcage () () ())
-                                      #(ribcage #(x) #((top)) #("l-*-37222"))
+                                      #(ribcage #(x) #((top)) #("l-*-37457"))
                                       #(ribcage
                                         (with-syntax)
                                         ((top))
@@ -17993,24 +18013,24 @@
                                             ((top))
                                             (hygiene guile))))))
                                      (hygiene guile))
-                                  in-37273)
+                                  in-37508)
                             '()
-                            (list out-37272
+                            (list out-37507
                                   (cons '#(syntax-object
                                            let
                                            ((top)
                                             #(ribcage
                                               #(out in e1 e2)
                                               #((top) (top) (top) (top))
-                                              #("l-*-37241"
-                                                "l-*-37242"
-                                                "l-*-37243"
-                                                "l-*-37244"))
+                                              #("l-*-37476"
+                                                "l-*-37477"
+                                                "l-*-37478"
+                                                "l-*-37479"))
                                             #(ribcage () () ())
                                             #(ribcage
                                               #(x)
                                               #((top))
-                                              #("l-*-37222"))
+                                              #("l-*-37457"))
                                             #(ribcage
                                               (with-syntax)
                                               ((top))
@@ -18021,40 +18041,40 @@
                                                   ((top))
                                                   (hygiene guile))))))
                                            (hygiene guile))
-                                        (cons '() (cons e1-37274 e2-37275))))))
-                    tmp-37268)
+                                        (cons '() (cons e1-37509 e2-37510))))))
+                    tmp-37503)
                   (syntax-violation
                     #f
                     "source expression failed to match any pattern"
-                    x-37252))))))))))
+                    x-37487))))))))))
 
 (define syntax-rules
   (make-syntax-transformer
     'syntax-rules
     'macro
-    (lambda (x-37330)
-      (let ((tmp-37332
+    (lambda (x-37565)
+      (let ((tmp-37567
               ($sc-dispatch
-                x-37330
+                x-37565
                 '(_ each-any . #(each ((any . any) any))))))
-        (if tmp-37332
+        (if tmp-37567
           (@apply
-            (lambda (k-37336
-                     keyword-37337
-                     pattern-37338
-                     template-37339)
+            (lambda (k-37571
+                     keyword-37572
+                     pattern-37573
+                     template-37574)
               (list '#(syntax-object
                        lambda
                        ((top)
                         #(ribcage
                           #(k keyword pattern template)
                           #((top) (top) (top) (top))
-                          #("l-*-37293"
-                            "l-*-37294"
-                            "l-*-37295"
-                            "l-*-37296"))
+                          #("l-*-37528"
+                            "l-*-37529"
+                            "l-*-37530"
+                            "l-*-37531"))
                         #(ribcage () () ())
-                        #(ribcage #(x) #((top)) #("l-*-37290"))
+                        #(ribcage #(x) #((top)) #("l-*-37525"))
                         #(ribcage
                           (syntax-rules)
                           ((top))
@@ -18071,12 +18091,12 @@
                          #(ribcage
                            #(k keyword pattern template)
                            #((top) (top) (top) (top))
-                           #("l-*-37293"
-                             "l-*-37294"
-                             "l-*-37295"
-                             "l-*-37296"))
+                           #("l-*-37528"
+                             "l-*-37529"
+                             "l-*-37530"
+                             "l-*-37531"))
                          #(ribcage () () ())
-                         #(ribcage #(x) #((top)) #("l-*-37290"))
+                         #(ribcage #(x) #((top)) #("l-*-37525"))
                          #(ribcage
                            (syntax-rules)
                            ((top))
@@ -18094,12 +18114,12 @@
                            #(ribcage
                              #(k keyword pattern template)
                              #((top) (top) (top) (top))
-                             #("l-*-37293"
-                               "l-*-37294"
-                               "l-*-37295"
-                               "l-*-37296"))
+                             #("l-*-37528"
+                               "l-*-37529"
+                               "l-*-37530"
+                               "l-*-37531"))
                            #(ribcage () () ())
-                           #(ribcage #(x) #((top)) #("l-*-37290"))
+                           #(ribcage #(x) #((top)) #("l-*-37525"))
                            #(ribcage
                              (syntax-rules)
                              ((top))
@@ -18117,12 +18137,12 @@
                            #(ribcage
                              #(k keyword pattern template)
                              #((top) (top) (top) (top))
-                             #("l-*-37293"
-                               "l-*-37294"
-                               "l-*-37295"
-                               "l-*-37296"))
+                             #("l-*-37528"
+                               "l-*-37529"
+                               "l-*-37530"
+                               "l-*-37531"))
                            #(ribcage () () ())
-                           #(ribcage #(x) #((top)) #("l-*-37290"))
+                           #(ribcage #(x) #((top)) #("l-*-37525"))
                            #(ribcage
                              (syntax-rules)
                              ((top))
@@ -18139,12 +18159,12 @@
                                 #(ribcage
                                   #(k keyword pattern template)
                                   #((top) (top) (top) (top))
-                                  #("l-*-37293"
-                                    "l-*-37294"
-                                    "l-*-37295"
-                                    "l-*-37296"))
+                                  #("l-*-37528"
+                                    "l-*-37529"
+                                    "l-*-37530"
+                                    "l-*-37531"))
                                 #(ribcage () () ())
-                                #(ribcage #(x) #((top)) #("l-*-37290"))
+                                #(ribcage #(x) #((top)) #("l-*-37525"))
                                 #(ribcage
                                   (syntax-rules)
                                   ((top))
@@ -18155,19 +18175,19 @@
                                       ((top))
                                       (hygiene guile))))))
                                (hygiene guile))
-                            pattern-37338))
+                            pattern-37573))
                     (cons '#(syntax-object
                              syntax-case
                              ((top)
                               #(ribcage
                                 #(k keyword pattern template)
                                 #((top) (top) (top) (top))
-                                #("l-*-37293"
-                                  "l-*-37294"
-                                  "l-*-37295"
-                                  "l-*-37296"))
+                                #("l-*-37528"
+                                  "l-*-37529"
+                                  "l-*-37530"
+                                  "l-*-37531"))
                               #(ribcage () () ())
-                              #(ribcage #(x) #((top)) #("l-*-37290"))
+                              #(ribcage #(x) #((top)) #("l-*-37525"))
                               #(ribcage
                                 (syntax-rules)
                                 ((top))
@@ -18184,12 +18204,12 @@
                                     #(ribcage
                                       #(k keyword pattern template)
                                       #((top) (top) (top) (top))
-                                      #("l-*-37293"
-                                        "l-*-37294"
-                                        "l-*-37295"
-                                        "l-*-37296"))
+                                      #("l-*-37528"
+                                        "l-*-37529"
+                                        "l-*-37530"
+                                        "l-*-37531"))
                                     #(ribcage () () ())
-                                    #(ribcage #(x) #((top)) #("l-*-37290"))
+                                    #(ribcage #(x) #((top)) #("l-*-37525"))
                                     #(ribcage
                                       (syntax-rules)
                                       ((top))
@@ -18200,9 +18220,9 @@
                                           ((top))
                                           (hygiene guile))))))
                                    (hygiene guile))
-                                (cons k-37336
-                                      (map (lambda (tmp-37304-37340
-                                                    tmp-37303-37341)
+                                (cons k-37571
+                                      (map (lambda (tmp-37539-37575
+                                                    tmp-37538-37576)
                                              (list (cons '#(syntax-object
                                                             _
                                                             ((top)
@@ -18215,10 +18235,10 @@
                                                                  (top)
                                                                  (top)
                                                                  (top))
-                                                               #("l-*-37293"
-                                                                 "l-*-37294"
-                                                                 "l-*-37295"
-                                                                 "l-*-37296"))
+                                                               #("l-*-37528"
+                                                                 "l-*-37529"
+                                                                 "l-*-37530"
+                                                                 "l-*-37531"))
                                                              #(ribcage
                                                                ()
                                                                ()
@@ -18226,7 +18246,7 @@
                                                              #(ribcage
                                                                #(x)
                                                                #((top))
-                                                               #("l-*-37290"))
+                                                               #("l-*-37525"))
                                                              #(ribcage
                                                                (syntax-rules)
                                                                ((top))
@@ -18239,7 +18259,7 @@
                                                                    (hygiene
                                                                      
guile))))))
                                                             (hygiene guile))
-                                                         tmp-37303-37341)
+                                                         tmp-37538-37576)
                                                    (list '#(syntax-object
                                                             syntax
                                                             ((top)
@@ -18252,10 +18272,10 @@
                                                                  (top)
                                                                  (top)
                                                                  (top))
-                                                               #("l-*-37293"
-                                                                 "l-*-37294"
-                                                                 "l-*-37295"
-                                                                 "l-*-37296"))
+                                                               #("l-*-37528"
+                                                                 "l-*-37529"
+                                                                 "l-*-37530"
+                                                                 "l-*-37531"))
                                                              #(ribcage
                                                                ()
                                                                ()
@@ -18263,7 +18283,7 @@
                                                              #(ribcage
                                                                #(x)
                                                                #((top))
-                                                               #("l-*-37290"))
+                                                               #("l-*-37525"))
                                                              #(ribcage
                                                                (syntax-rules)
                                                                ((top))
@@ -18276,43 +18296,43 @@
                                                                    (hygiene
                                                                      
guile))))))
                                                             (hygiene guile))
-                                                         tmp-37304-37340)))
-                                           template-37339
-                                           pattern-37338))))))
-            tmp-37332)
-          (let ((tmp-37342
+                                                         tmp-37539-37575)))
+                                           template-37574
+                                           pattern-37573))))))
+            tmp-37567)
+          (let ((tmp-37577
                   ($sc-dispatch
-                    x-37330
+                    x-37565
                     '(_ each-any any . #(each ((any . any) any))))))
-            (if (if tmp-37342
+            (if (if tmp-37577
                   (@apply
-                    (lambda (k-37346
-                             docstring-37347
-                             keyword-37348
-                             pattern-37349
-                             template-37350)
-                      (string? (syntax->datum docstring-37347)))
-                    tmp-37342)
+                    (lambda (k-37581
+                             docstring-37582
+                             keyword-37583
+                             pattern-37584
+                             template-37585)
+                      (string? (syntax->datum docstring-37582)))
+                    tmp-37577)
                   #f)
               (@apply
-                (lambda (k-37351
-                         docstring-37352
-                         keyword-37353
-                         pattern-37354
-                         template-37355)
+                (lambda (k-37586
+                         docstring-37587
+                         keyword-37588
+                         pattern-37589
+                         template-37590)
                   (list '#(syntax-object
                            lambda
                            ((top)
                             #(ribcage
                               #(k docstring keyword pattern template)
                               #((top) (top) (top) (top) (top))
-                              #("l-*-37316"
-                                "l-*-37317"
-                                "l-*-37318"
-                                "l-*-37319"
-                                "l-*-37320"))
+                              #("l-*-37551"
+                                "l-*-37552"
+                                "l-*-37553"
+                                "l-*-37554"
+                                "l-*-37555"))
                             #(ribcage () () ())
-                            #(ribcage #(x) #((top)) #("l-*-37290"))
+                            #(ribcage #(x) #((top)) #("l-*-37525"))
                             #(ribcage
                               (syntax-rules)
                               ((top))
@@ -18329,13 +18349,13 @@
                              #(ribcage
                                #(k docstring keyword pattern template)
                                #((top) (top) (top) (top) (top))
-                               #("l-*-37316"
-                                 "l-*-37317"
-                                 "l-*-37318"
-                                 "l-*-37319"
-                                 "l-*-37320"))
+                               #("l-*-37551"
+                                 "l-*-37552"
+                                 "l-*-37553"
+                                 "l-*-37554"
+                                 "l-*-37555"))
                              #(ribcage () () ())
-                             #(ribcage #(x) #((top)) #("l-*-37290"))
+                             #(ribcage #(x) #((top)) #("l-*-37525"))
                              #(ribcage
                                (syntax-rules)
                                ((top))
@@ -18346,7 +18366,7 @@
                                    ((top))
                                    (hygiene guile))))))
                             (hygiene guile)))
-                        docstring-37352
+                        docstring-37587
                         (vector
                           '(#(syntax-object
                               macro-type
@@ -18354,13 +18374,13 @@
                                #(ribcage
                                  #(k docstring keyword pattern template)
                                  #((top) (top) (top) (top) (top))
-                                 #("l-*-37316"
-                                   "l-*-37317"
-                                   "l-*-37318"
-                                   "l-*-37319"
-                                   "l-*-37320"))
+                                 #("l-*-37551"
+                                   "l-*-37552"
+                                   "l-*-37553"
+                                   "l-*-37554"
+                                   "l-*-37555"))
                                #(ribcage () () ())
-                               #(ribcage #(x) #((top)) #("l-*-37290"))
+                               #(ribcage #(x) #((top)) #("l-*-37525"))
                                #(ribcage
                                  (syntax-rules)
                                  ((top))
@@ -18378,13 +18398,13 @@
                                #(ribcage
                                  #(k docstring keyword pattern template)
                                  #((top) (top) (top) (top) (top))
-                                 #("l-*-37316"
-                                   "l-*-37317"
-                                   "l-*-37318"
-                                   "l-*-37319"
-                                   "l-*-37320"))
+                                 #("l-*-37551"
+                                   "l-*-37552"
+                                   "l-*-37553"
+                                   "l-*-37554"
+                                   "l-*-37555"))
                                #(ribcage () () ())
-                               #(ribcage #(x) #((top)) #("l-*-37290"))
+                               #(ribcage #(x) #((top)) #("l-*-37525"))
                                #(ribcage
                                  (syntax-rules)
                                  ((top))
@@ -18401,13 +18421,13 @@
                                     #(ribcage
                                       #(k docstring keyword pattern template)
                                       #((top) (top) (top) (top) (top))
-                                      #("l-*-37316"
-                                        "l-*-37317"
-                                        "l-*-37318"
-                                        "l-*-37319"
-                                        "l-*-37320"))
+                                      #("l-*-37551"
+                                        "l-*-37552"
+                                        "l-*-37553"
+                                        "l-*-37554"
+                                        "l-*-37555"))
                                     #(ribcage () () ())
-                                    #(ribcage #(x) #((top)) #("l-*-37290"))
+                                    #(ribcage #(x) #((top)) #("l-*-37525"))
                                     #(ribcage
                                       (syntax-rules)
                                       ((top))
@@ -18418,20 +18438,20 @@
                                           ((top))
                                           (hygiene guile))))))
                                    (hygiene guile))
-                                pattern-37354))
+                                pattern-37589))
                         (cons '#(syntax-object
                                  syntax-case
                                  ((top)
                                   #(ribcage
                                     #(k docstring keyword pattern template)
                                     #((top) (top) (top) (top) (top))
-                                    #("l-*-37316"
-                                      "l-*-37317"
-                                      "l-*-37318"
-                                      "l-*-37319"
-                                      "l-*-37320"))
+                                    #("l-*-37551"
+                                      "l-*-37552"
+                                      "l-*-37553"
+                                      "l-*-37554"
+                                      "l-*-37555"))
                                   #(ribcage () () ())
-                                  #(ribcage #(x) #((top)) #("l-*-37290"))
+                                  #(ribcage #(x) #((top)) #("l-*-37525"))
                                   #(ribcage
                                     (syntax-rules)
                                     ((top))
@@ -18452,13 +18472,13 @@
                                             pattern
                                             template)
                                           #((top) (top) (top) (top) (top))
-                                          #("l-*-37316"
-                                            "l-*-37317"
-                                            "l-*-37318"
-                                            "l-*-37319"
-                                            "l-*-37320"))
+                                          #("l-*-37551"
+                                            "l-*-37552"
+                                            "l-*-37553"
+                                            "l-*-37554"
+                                            "l-*-37555"))
                                         #(ribcage () () ())
-                                        #(ribcage #(x) #((top)) #("l-*-37290"))
+                                        #(ribcage #(x) #((top)) #("l-*-37525"))
                                         #(ribcage
                                           (syntax-rules)
                                           ((top))
@@ -18469,9 +18489,9 @@
                                               ((top))
                                               (hygiene guile))))))
                                        (hygiene guile))
-                                    (cons k-37351
-                                          (map (lambda (tmp-37329-37356
-                                                        tmp-37328-37357)
+                                    (cons k-37586
+                                          (map (lambda (tmp-37564-37591
+                                                        tmp-37563-37592)
                                                  (list (cons '#(syntax-object
                                                                 _
                                                                 ((top)
@@ -18486,11 +18506,11 @@
                                                                      (top)
                                                                      (top)
                                                                      (top))
-                                                                   
#("l-*-37316"
-                                                                     
"l-*-37317"
-                                                                     
"l-*-37318"
-                                                                     
"l-*-37319"
-                                                                     
"l-*-37320"))
+                                                                   
#("l-*-37551"
+                                                                     
"l-*-37552"
+                                                                     
"l-*-37553"
+                                                                     
"l-*-37554"
+                                                                     
"l-*-37555"))
                                                                  #(ribcage
                                                                    ()
                                                                    ()
@@ -18498,7 +18518,7 @@
                                                                  #(ribcage
                                                                    #(x)
                                                                    #((top))
-                                                                   
#("l-*-37290"))
+                                                                   
#("l-*-37525"))
                                                                  #(ribcage
                                                                    
(syntax-rules)
                                                                    ((top))
@@ -18512,7 +18532,7 @@
                                                                          
guile))))))
                                                                 (hygiene
                                                                   guile))
-                                                             tmp-37328-37357)
+                                                             tmp-37563-37592)
                                                        (list '#(syntax-object
                                                                 syntax
                                                                 ((top)
@@ -18527,11 +18547,11 @@
                                                                      (top)
                                                                      (top)
                                                                      (top))
-                                                                   
#("l-*-37316"
-                                                                     
"l-*-37317"
-                                                                     
"l-*-37318"
-                                                                     
"l-*-37319"
-                                                                     
"l-*-37320"))
+                                                                   
#("l-*-37551"
+                                                                     
"l-*-37552"
+                                                                     
"l-*-37553"
+                                                                     
"l-*-37554"
+                                                                     
"l-*-37555"))
                                                                  #(ribcage
                                                                    ()
                                                                    ()
@@ -18539,7 +18559,7 @@
                                                                  #(ribcage
                                                                    #(x)
                                                                    #((top))
-                                                                   
#("l-*-37290"))
+                                                                   
#("l-*-37525"))
                                                                  #(ribcage
                                                                    
(syntax-rules)
                                                                    ((top))
@@ -18553,34 +18573,34 @@
                                                                          
guile))))))
                                                                 (hygiene
                                                                   guile))
-                                                             tmp-37329-37356)))
-                                               template-37355
-                                               pattern-37354))))))
-                tmp-37342)
+                                                             tmp-37564-37591)))
+                                               template-37590
+                                               pattern-37589))))))
+                tmp-37577)
               (syntax-violation
                 #f
                 "source expression failed to match any pattern"
-                x-37330))))))))
+                x-37565))))))))
 
 (define define-syntax-rule
   (make-syntax-transformer
     'define-syntax-rule
     'macro
-    (lambda (x-37395)
-      (let ((tmp-37397
-              ($sc-dispatch x-37395 '(_ (any . any) any))))
-        (if tmp-37397
+    (lambda (x-37630)
+      (let ((tmp-37632
+              ($sc-dispatch x-37630 '(_ (any . any) any))))
+        (if tmp-37632
           (@apply
-            (lambda (name-37401 pattern-37402 template-37403)
+            (lambda (name-37636 pattern-37637 template-37638)
               (list '#(syntax-object
                        define-syntax
                        ((top)
                         #(ribcage
                           #(name pattern template)
                           #((top) (top) (top))
-                          #("l-*-37372" "l-*-37373" "l-*-37374"))
+                          #("l-*-37607" "l-*-37608" "l-*-37609"))
                         #(ribcage () () ())
-                        #(ribcage #(x) #((top)) #("l-*-37369"))
+                        #(ribcage #(x) #((top)) #("l-*-37604"))
                         #(ribcage
                           (define-syntax-rule)
                           ((top))
@@ -18591,16 +18611,16 @@
                               ((top))
                               (hygiene guile))))))
                        (hygiene guile))
-                    name-37401
+                    name-37636
                     (list '#(syntax-object
                              syntax-rules
                              ((top)
                               #(ribcage
                                 #(name pattern template)
                                 #((top) (top) (top))
-                                #("l-*-37372" "l-*-37373" "l-*-37374"))
+                                #("l-*-37607" "l-*-37608" "l-*-37609"))
                               #(ribcage () () ())
-                              #(ribcage #(x) #((top)) #("l-*-37369"))
+                              #(ribcage #(x) #((top)) #("l-*-37604"))
                               #(ribcage
                                 (define-syntax-rule)
                                 ((top))
@@ -18618,14 +18638,14 @@
                                           #(ribcage
                                             #(name pattern template)
                                             #((top) (top) (top))
-                                            #("l-*-37372"
-                                              "l-*-37373"
-                                              "l-*-37374"))
+                                            #("l-*-37607"
+                                              "l-*-37608"
+                                              "l-*-37609"))
                                           #(ribcage () () ())
                                           #(ribcage
                                             #(x)
                                             #((top))
-                                            #("l-*-37369"))
+                                            #("l-*-37604"))
                                           #(ribcage
                                             (define-syntax-rule)
                                             ((top))
@@ -18636,37 +18656,37 @@
                                                 ((top))
                                                 (hygiene guile))))))
                                          (hygiene guile))
-                                      pattern-37402)
-                                template-37403))))
-            tmp-37397)
-          (let ((tmp-37404
-                  ($sc-dispatch x-37395 '(_ (any . any) any any))))
-            (if (if tmp-37404
+