guile-commits
[Top][All Lists]
Advanced

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

[Guile-commits] GNU Guile branch, stable-2.0, updated. v2.0.5-72-g1af6d2


From: Mark H Weaver
Subject: [Guile-commits] GNU Guile branch, stable-2.0, updated. v2.0.5-72-g1af6d2a
Date: Sat, 03 Mar 2012 23:09:28 +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=1af6d2a717f499564fbbc297c79e00ac14b0dcf9

The branch, stable-2.0 has been updated
       via  1af6d2a717f499564fbbc297c79e00ac14b0dcf9 (commit)
       via  72ee0ef71b9a0514874976cdcf3ea9d5333db4b1 (commit)
       via  8c43b28a1136aba186fd211b0f6037cf0c35f006 (commit)
      from  9120f130a8ccd237d31806f381a1a1a25f5d930a (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 1af6d2a717f499564fbbc297c79e00ac14b0dcf9
Author: Mark H Weaver <address@hidden>
Date:   Fri Mar 2 18:40:43 2012 -0500

    Minimize size of embedded syntax objects in psyntax-pp.scm
    
    * module/ice-9/compile-psyntax.scm: Minimize syntax object literals
      embedded in psyntax-pp.scm.
    
    * module/ice-9/psyntax.scm: Rename a few variables so that syntax
      objects embedded in macros have no lexical bindings, so that their
      minimized syntax objects will have no embedded labels.  These labels
      were the last remaining gensym counters in psyntax-pp.scm.
    
    * module/ice-9/psyntax-pp.scm: Regenerate.  It is now less than one
      quarter of its previous size!  More importantly, this file no longer
      contains any gensym counters, which means that in the future, local
      changes to psyntax.scm will usually result in only local changes to
      psyntax-pp.scm.

commit 72ee0ef71b9a0514874976cdcf3ea9d5333db4b1
Author: Mark H Weaver <address@hidden>
Date:   Thu Mar 1 17:56:14 2012 -0500

    tree-il->scheme improvements
    
    * module/language/tree-il.scm (tree-il->scheme): New implementation that
      simply calls 'decompile-tree-il'.
    
    * module/language/scheme/decompile-tree-il.scm (choose-output-names,
      do-decompile): New internal procedures.
    
      (decompile-tree-il): New and improved implementation.  Print source
      identifiers where possible, otherwise add minimal numeric suffixes.
      Previously we printed the gensyms.  Avoid 'begin' in contexts that
      provide an implicit 'begin'.  Produce 'cond', 'case', 'and', 'or',
      'let*', named let, and internal defines where appropriate.  Recognize
      keyword arguments in 'opts' to disable the production of these derived
      syntactic forms, and to optionally strip numeric suffixes from
      variable names.
    
    * module/ice-9/compile-psyntax.scm: Disable partial evaluation, letrec
      fixing, and primitive expansion when producing psyntax-pp.scm, in
      order to produce output as close to the original source as practical.
      Disable production of derived syntactic forms as needed during
      bootstrap.  Strip numeric suffixes from variable names.  Adjust
      pretty-printing parameters.
    
    * module/ice-9/psyntax-pp.scm: Regenerate.  It is now less than half
      of the original size.

commit 8c43b28a1136aba186fd211b0f6037cf0c35f006
Author: Mark H Weaver <address@hidden>
Date:   Sun Feb 26 15:58:30 2012 -0500

    pretty-print: allow max-expr-width to be set; recognize more keywords
    
    * module/ice-9/pretty-print.scm (pretty-print): Add new keyword argument
      '#:max-expr-width'.
    
      (generic-write): Add new argument 'max-expr-width'.  Previously this
      was internally defined to the constant value 50.

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

Summary of changes:
 module/ice-9/compile-psyntax.scm             |   80 +-
 module/ice-9/pretty-print.scm                |   16 +-
 module/ice-9/psyntax-pp.scm                  |29904 +++-----------------------
 module/ice-9/psyntax.scm                     |    8 +-
 module/language/scheme/decompile-tree-il.scm |  795 +-
 module/language/tree-il.scm                  |  155 +-
 6 files changed, 4022 insertions(+), 26936 deletions(-)

diff --git a/module/ice-9/compile-psyntax.scm b/module/ice-9/compile-psyntax.scm
index 3d803e9..201ae39 100644
--- a/module/ice-9/compile-psyntax.scm
+++ b/module/ice-9/compile-psyntax.scm
@@ -17,11 +17,70 @@
 ;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 
USA
 
 (use-modules (language tree-il)
-             (language tree-il optimize)
+             (language tree-il primitives)
              (language tree-il canonicalize)
+             (srfi srfi-1)
              (ice-9 pretty-print)
              (system syntax))
 
+;; Minimize a syntax-object such that it can no longer be used as the
+;; first argument to 'datum->syntax', but is otherwise equivalent.
+(define (squeeze-syntax-object! syn)
+  (define (ensure-list x) (if (vector? x) (vector->list x) x))
+  (let ((x    (vector-ref syn 1))
+        (wrap (vector-ref syn 2))
+        (mod  (vector-ref syn 3)))
+    (let ((marks (car wrap))
+          (subst (cdr wrap)))
+      (define (set-wrap! marks subst)
+        (vector-set! syn 2 (cons marks subst)))
+      (cond
+       ((symbol? x)
+        (let loop ((marks marks) (subst subst))
+          (cond
+           ((null? subst) (set-wrap! marks subst) syn)
+           ((eq? 'shift (car subst)) (loop (cdr marks) (cdr subst)))
+           ((find (lambda (entry) (and (eq? x (car entry))
+                                       (equal? marks (cadr entry))))
+                  (apply map list (map ensure-list
+                                       (cdr (vector->list (car subst))))))
+            => (lambda (entry)
+                 (set-wrap! marks
+                            (list (list->vector
+                                   (cons 'ribcage
+                                         (map vector entry)))))
+                 syn))
+           (else (loop marks (cdr subst))))))
+       ((or (pair? x) (vector? x))
+        syn)
+       (else x)))))
+
+(define (squeeze-constant! x)
+  (define (syntax-object? x)
+    (and (vector? x)
+         (= 4 (vector-length x))
+         (eq? 'syntax-object (vector-ref x 0))))
+  (cond ((syntax-object? x)
+         (squeeze-syntax-object! x))
+        ((pair? x)
+         (set-car! x (squeeze-constant! (car x)))
+         (set-cdr! x (squeeze-constant! (cdr x)))
+         x)
+        ((vector? x)
+         (for-each (lambda (i)
+                     (vector-set! x i (squeeze-constant! (vector-ref x i))))
+                   (iota (vector-length x)))
+         x)
+        (else x)))
+
+(define (squeeze-tree-il! x)
+  (post-order! (lambda (x)
+                 (if (const? x)
+                     (set! (const-exp x)
+                           (squeeze-constant! (const-exp x))))
+                 #f)
+               x))
+
 ;; Avoid gratuitous churn in psyntax-pp.scm due to the marks and labels
 ;; changing session identifiers.
 (set! syntax-session-id (lambda () "*"))
@@ -40,12 +99,19 @@
             (close-port in))
           (begin
             (pretty-print (tree-il->scheme
-                           (canonicalize!
-                            (optimize!
-                             (macroexpand x 'c '(compile load eval))
-                             (current-module)
-                             '())))
-                          out)
+                           (squeeze-tree-il!
+                            (canonicalize!
+                             (resolve-primitives!
+                              (macroexpand x 'c '(compile load eval))
+                              (current-module))))
+                           (current-module)
+                           (list #:avoid-lambda? #f
+                                 #:use-case? #f
+                                 #:strip-numeric-suffixes? #t
+                                 #:use-derived-syntax?
+                                 (and (pair? x)
+                                      (eq? 'let (car x)))))
+                          out #:width 120 #:max-expr-width 70)
             (newline out)
             (loop (read in))))))
   (system (format #f "mv -f ~s.tmp ~s" target target)))
diff --git a/module/ice-9/pretty-print.scm b/module/ice-9/pretty-print.scm
index 8a0c0b8..bf45eed 100644
--- a/module/ice-9/pretty-print.scm
+++ b/module/ice-9/pretty-print.scm
@@ -1,6 +1,7 @@
 ;;;; -*- coding: utf-8; mode: scheme -*-
 ;;;;
-;;;;   Copyright (C) 2001, 2004, 2006, 2009, 2010 Free Software Foundation, 
Inc.
+;;;;   Copyright (C) 2001, 2004, 2006, 2009, 2010,
+;;;;      2012 Free Software Foundation, Inc.
 ;;;; 
 ;;;; This library is free software; you can redistribute it and/or
 ;;;; modify it under the terms of the GNU Lesser General Public
@@ -32,7 +33,8 @@
 
 (define genwrite:newline-str (make-string 1 #\newline))
 
-(define (generic-write obj display? width per-line-prefix output)
+(define (generic-write
+         obj display? width max-expr-width per-line-prefix output)
 
   (define (read-macro? l)
     (define (length1? l) (and (pair? l) (null? (cdr l))))
@@ -93,7 +95,7 @@
       (if (or (pair? obj) (vector? obj)) ; may have to split on multiple lines
         (let ((result '())
               (left (min (+ (- (- width col) extra) 1) max-expr-width)))
-          (generic-write obj display? #f ""
+          (generic-write obj display? #f max-expr-width ""
             (lambda (str)
               (set! result (cons str result))
               (set! left (- left (string-length str)))
@@ -223,12 +225,10 @@
 
     (define max-call-head-width 5)
 
-    (define max-expr-width 50)
-
     (define (style head)
       (case head
-        ((lambda let* letrec define define-public
-          define-syntax let-syntax letrec-syntax)
+        ((lambda lambda* let* letrec define define* define-public
+                 define-syntax let-syntax letrec-syntax with-syntax)
                                      pp-LAMBDA)
         ((if set!)                   pp-IF)
         ((cond)                      pp-COND)
@@ -273,6 +273,7 @@
                        #:key 
                        (port (or port* (current-output-port)))
                        (width 79)
+                       (max-expr-width 50)
                        (display? #f)
                        (per-line-prefix ""))
   "Pretty-print OBJ on PORT, which is a keyword argument defaulting to
@@ -286,6 +287,7 @@ Instead of with a keyword argument, you can also specify 
the output
 port directly after OBJ, like (pretty-print OBJ PORT)."
   (generic-write obj display?
                 (- width (string-length per-line-prefix))
+                 max-expr-width
                 per-line-prefix
                 (lambda (s) (display s port) #t)))
 
diff --git a/module/ice-9/psyntax-pp.scm b/module/ice-9/psyntax-pp.scm
index d11a3f8..5635a6a 100644
--- a/module/ice-9/psyntax-pp.scm
+++ b/module/ice-9/psyntax-pp.scm
@@ -1,26890 +1,3264 @@
 (eval-when (compile) (set-current-module (resolve-module (quote (guile)))))
 (if #f #f)
 
-(let ((session-id-4222 (if #f #f))
-      (transformer-environment-4283 (if #f #f)))
-  (letrec*
-    ((top-level-eval-hook-4220
-       (lambda (x-24656 mod-24657)
-         (primitive-eval x-24656)))
-     (get-global-definition-hook-4224
-       (lambda (symbol-14704 module-14705)
-         (begin
-           (if (if (not module-14705) (current-module) #f)
-             (warn "module system is booted, we should have a module"
-                   symbol-14704))
-           (let ((v-14706
-                   (module-variable
-                     (if module-14705
-                       (resolve-module (cdr module-14705))
-                       (current-module))
-                     symbol-14704)))
-             (if v-14706
-               (if (variable-bound? v-14706)
-                 (let ((val-14708 (variable-ref v-14706)))
-                   (if (macro? val-14708)
-                     (if (macro-type val-14708)
-                       (cons (macro-type val-14708)
-                             (macro-binding val-14708))
-                       #f)
-                     #f))
-                 #f)
-               #f)))))
-     (maybe-name-value!-4226
-       (lambda (name-21545 val-21546)
-         (if (if (struct? val-21546)
-               (eq? (struct-vtable val-21546)
-                    (vector-ref %expanded-vtables 13))
-               #f)
-           (let ((meta-21553 (struct-ref val-21546 1)))
-             (if (not (assq 'name meta-21553))
-               (let ((v-21558
-                       (cons (cons 'name name-21545) meta-21553)))
-                 (struct-set! val-21546 1 v-21558)))))))
-     (build-application-4228
-       (lambda (source-14710 fun-exp-14711 arg-exps-14712)
-         (make-struct/no-tail
-           (vector-ref %expanded-vtables 11)
-           source-14710
-           fun-exp-14711
-           arg-exps-14712)))
-     (analyze-variable-4233
-       (lambda (mod-14718
-                var-14719
-                modref-cont-14720
-                bare-cont-14721)
-         (if (not mod-14718)
-           (bare-cont-14721 var-14719)
-           (let ((kind-14722 (car mod-14718))
-                 (mod-14723 (cdr mod-14718)))
-             (if (eqv? kind-14722 'public)
-               (modref-cont-14720 mod-14723 var-14719 #t)
-               (if (eqv? kind-14722 'private)
-                 (if (not (equal? mod-14723 (module-name (current-module))))
-                   (modref-cont-14720 mod-14723 var-14719 #f)
-                   (bare-cont-14721 var-14719))
-                 (if (eqv? kind-14722 'bare)
-                   (bare-cont-14721 var-14719)
-                   (if (eqv? kind-14722 'hygiene)
-                     (if (if (not (equal?
-                                    mod-14723
-                                    (module-name (current-module))))
-                           (module-variable
-                             (resolve-module mod-14723)
-                             var-14719)
-                           #f)
-                       (modref-cont-14720 mod-14723 var-14719 #f)
-                       (bare-cont-14721 var-14719))
-                     (syntax-violation
-                       #f
-                       "bad module kind"
-                       var-14719
-                       mod-14723)))))))))
-     (build-simple-lambda-4237
-       (lambda (src-14750
-                req-14751
-                rest-14752
-                vars-14753
-                meta-14754
-                exp-14755)
-         (let ((body-14761
-                 (make-struct/no-tail
-                   (vector-ref %expanded-vtables 14)
-                   src-14750
-                   req-14751
-                   #f
-                   rest-14752
-                   #f
-                   '()
-                   vars-14753
-                   exp-14755
-                   #f)))
-           (make-struct/no-tail
-             (vector-ref %expanded-vtables 13)
-             src-14750
-             meta-14754
-             body-14761))))
-     (build-sequence-4242
-       (lambda (src-24658 exps-24659)
-         (if (null? (cdr exps-24659))
-           (car exps-24659)
-           (make-struct/no-tail
-             (vector-ref %expanded-vtables 12)
-             src-24658
-             exps-24659))))
-     (build-let-4243
-       (lambda (src-14773
-                ids-14774
-                vars-14775
-                val-exps-14776
-                body-exp-14777)
+(letrec*
+  ((make-void
+     (lambda (src) (make-struct (vector-ref %expanded-vtables 0) 0 src)))
+   (make-const
+     (lambda (src exp)
+       (make-struct (vector-ref %expanded-vtables 1) 0 src exp)))
+   (make-primitive-ref
+     (lambda (src name)
+       (make-struct (vector-ref %expanded-vtables 2) 0 src name)))
+   (make-lexical-ref
+     (lambda (src name gensym)
+       (make-struct (vector-ref %expanded-vtables 3) 0 src name gensym)))
+   (make-lexical-set
+     (lambda (src name gensym exp)
+       (make-struct (vector-ref %expanded-vtables 4) 0 src name gensym exp)))
+   (make-module-ref
+     (lambda (src mod name public?)
+       (make-struct (vector-ref %expanded-vtables 5) 0 src mod name public?)))
+   (make-module-set
+     (lambda (src mod name public? exp)
+       (make-struct
+         (vector-ref %expanded-vtables 6)
+         0
+         src
+         mod
+         name
+         public?
+         exp)))
+   (make-toplevel-ref
+     (lambda (src name)
+       (make-struct (vector-ref %expanded-vtables 7) 0 src name)))
+   (make-toplevel-set
+     (lambda (src name exp)
+       (make-struct (vector-ref %expanded-vtables 8) 0 src name exp)))
+   (make-toplevel-define
+     (lambda (src name exp)
+       (make-struct (vector-ref %expanded-vtables 9) 0 src name exp)))
+   (make-conditional
+     (lambda (src test consequent alternate)
+       (make-struct
+         (vector-ref %expanded-vtables 10)
+         0
+         src
+         test
+         consequent
+         alternate)))
+   (make-application
+     (lambda (src proc args)
+       (make-struct (vector-ref %expanded-vtables 11) 0 src proc args)))
+   (make-sequence
+     (lambda (src exps)
+       (make-struct (vector-ref %expanded-vtables 12) 0 src exps)))
+   (make-lambda
+     (lambda (src meta body)
+       (make-struct (vector-ref %expanded-vtables 13) 0 src meta body)))
+   (make-lambda-case
+     (lambda (src req opt rest kw inits gensyms body alternate)
+       (make-struct
+         (vector-ref %expanded-vtables 14)
+         0
+         src
+         req
+         opt
+         rest
+         kw
+         inits
+         gensyms
+         body
+         alternate)))
+   (make-let
+     (lambda (src names gensyms vals body)
+       (make-struct
+         (vector-ref %expanded-vtables 15)
+         0
+         src
+         names
+         gensyms
+         vals
+         body)))
+   (make-letrec
+     (lambda (src in-order? names gensyms vals body)
+       (make-struct
+         (vector-ref %expanded-vtables 16)
+         0
+         src
+         in-order?
+         names
+         gensyms
+         vals
+         body)))
+   (make-dynlet
+     (lambda (src fluids vals body)
+       (make-struct
+         (vector-ref %expanded-vtables 17)
+         0
+         src
+         fluids
+         vals
+         body)))
+   (lambda?
+     (lambda (x)
+       (and (struct? x)
+            (eq? (struct-vtable x) (vector-ref %expanded-vtables 13)))))
+   (lambda-meta (lambda (x) (struct-ref x 1)))
+   (set-lambda-meta! (lambda (x v) (struct-set! x 1 v)))
+   (top-level-eval-hook (lambda (x mod) (primitive-eval x)))
+   (local-eval-hook (lambda (x mod) (primitive-eval x)))
+   (session-id
+     (let ((v (module-variable (current-module) 'syntax-session-id)))
+       (lambda () ((variable-ref v)))))
+   (put-global-definition-hook
+     (lambda (symbol type val)
+       (module-define!
+         (current-module)
+         symbol
+         (make-syntax-transformer symbol type val))))
+   (get-global-definition-hook
+     (lambda (symbol module)
+       (if (and (not module) (current-module))
+         (warn "module system is booted, we should have a module" symbol))
+       (let ((v (module-variable
+                  (if module (resolve-module (cdr module)) (current-module))
+                  symbol)))
+         (and v
+              (variable-bound? v)
+              (let ((val (variable-ref v)))
+                (and (macro? val)
+                     (macro-type val)
+                     (cons (macro-type val) (macro-binding val))))))))
+   (decorate-source
+     (lambda (e s)
+       (if (and s (supports-source-properties? e))
+         (set-source-properties! e s))
+       e))
+   (maybe-name-value!
+     (lambda (name val)
+       (if (lambda? val)
+         (let ((meta (lambda-meta val)))
+           (if (not (assq 'name meta))
+             (set-lambda-meta! val (acons 'name name meta)))))))
+   (build-void (lambda (source) (make-void source)))
+   (build-application
+     (lambda (source fun-exp arg-exps)
+       (make-application source fun-exp arg-exps)))
+   (build-conditional
+     (lambda (source test-exp then-exp else-exp)
+       (make-conditional source test-exp then-exp else-exp)))
+   (build-dynlet
+     (lambda (source fluids vals body)
+       (make-dynlet source fluids vals body)))
+   (build-lexical-reference
+     (lambda (type source name var) (make-lexical-ref source name var)))
+   (build-lexical-assignment
+     (lambda (source name var exp)
+       (maybe-name-value! name exp)
+       (make-lexical-set source name var exp)))
+   (analyze-variable
+     (lambda (mod var modref-cont bare-cont)
+       (if (not mod)
+         (bare-cont var)
+         (let ((kind (car mod)) (mod (cdr mod)))
+           (let ((key kind))
+             (cond ((memv key '(public)) (modref-cont mod var #t))
+                   ((memv key '(private))
+                    (if (not (equal? mod (module-name (current-module))))
+                      (modref-cont mod var #f)
+                      (bare-cont var)))
+                   ((memv key '(bare)) (bare-cont var))
+                   ((memv key '(hygiene))
+                    (if (and (not (equal? mod (module-name (current-module))))
+                             (module-variable (resolve-module mod) var))
+                      (modref-cont mod var #f)
+                      (bare-cont var)))
+                   (else (syntax-violation #f "bad module kind" var mod))))))))
+   (build-global-reference
+     (lambda (source var mod)
+       (analyze-variable
+         mod
+         var
+         (lambda (mod var public?) (make-module-ref source mod var public?))
+         (lambda (var) (make-toplevel-ref source var)))))
+   (build-global-assignment
+     (lambda (source var exp mod)
+       (maybe-name-value! var exp)
+       (analyze-variable
+         mod
+         var
+         (lambda (mod var public?)
+           (make-module-set source mod var public? exp))
+         (lambda (var) (make-toplevel-set source var exp)))))
+   (build-global-definition
+     (lambda (source var exp)
+       (maybe-name-value! var exp)
+       (make-toplevel-define source var exp)))
+   (build-simple-lambda
+     (lambda (src req rest vars meta exp)
+       (make-lambda
+         src
+         meta
+         (make-lambda-case src req #f rest #f '() vars exp #f))))
+   (build-case-lambda
+     (lambda (src meta body) (make-lambda src meta body)))
+   (build-lambda-case
+     (lambda (src req opt rest kw inits vars body else-case)
+       (make-lambda-case src req opt rest kw inits vars body else-case)))
+   (build-primref
+     (lambda (src name)
+       (if (equal? (module-name (current-module)) '(guile))
+         (make-toplevel-ref src name)
+         (make-module-ref src '(guile) name #f))))
+   (build-data (lambda (src exp) (make-const src exp)))
+   (build-sequence
+     (lambda (src exps)
+       (if (null? (cdr exps)) (car exps) (make-sequence src exps))))
+   (build-let
+     (lambda (src ids vars val-exps body-exp)
+       (for-each maybe-name-value! ids val-exps)
+       (if (null? vars) body-exp (make-let src ids vars val-exps body-exp))))
+   (build-named-let
+     (lambda (src ids vars val-exps body-exp)
+       (let ((f (car vars)) (f-name (car ids)) (vars (cdr vars)) (ids (cdr 
ids)))
+         (let ((proc (build-simple-lambda src ids #f vars '() body-exp)))
+           (maybe-name-value! f-name proc)
+           (for-each maybe-name-value! ids val-exps)
+           (make-letrec
+             src
+             #f
+             (list f-name)
+             (list f)
+             (list proc)
+             (build-application
+               src
+               (build-lexical-reference 'fun src f-name f)
+               val-exps))))))
+   (build-letrec
+     (lambda (src in-order? ids vars val-exps body-exp)
+       (if (null? vars)
+         body-exp
          (begin
-           (for-each
-             maybe-name-value!-4226
-             ids-14774
-             val-exps-14776)
-           (if (null? vars-14775)
-             body-exp-14777
-             (make-struct/no-tail
-               (vector-ref %expanded-vtables 15)
-               src-14773
-               ids-14774
-               vars-14775
-               val-exps-14776
-               body-exp-14777)))))
-     (build-named-let-4244
-       (lambda (src-14801
-                ids-14802
-                vars-14803
-                val-exps-14804
-                body-exp-14805)
-         (let ((f-14806 (car vars-14803))
-               (f-name-14807 (car ids-14802))
-               (vars-14808 (cdr vars-14803))
-               (ids-14809 (cdr ids-14802)))
-           (let ((proc-14810
-                   (let ((body-14830
-                           (make-struct/no-tail
-                             (vector-ref %expanded-vtables 14)
-                             src-14801
-                             ids-14809
-                             #f
-                             #f
-                             #f
-                             '()
-                             vars-14808
-                             body-exp-14805
-                             #f)))
-                     (make-struct/no-tail
-                       (vector-ref %expanded-vtables 13)
-                       src-14801
-                       '()
-                       body-14830))))
-             (begin
-               (if (if (struct? proc-14810)
-                     (eq? (struct-vtable proc-14810)
-                          (vector-ref %expanded-vtables 13))
-                     #f)
-                 (let ((meta-14854 (struct-ref proc-14810 1)))
-                   (if (not (assq 'name meta-14854))
-                     (let ((v-14861
-                             (cons (cons 'name f-name-14807) meta-14854)))
-                       (struct-set! proc-14810 1 v-14861)))))
-               (for-each
-                 maybe-name-value!-4226
-                 ids-14809
-                 val-exps-14804)
-               (let ((names-14885 (list f-name-14807))
-                     (gensyms-14886 (list f-14806))
-                     (vals-14887 (list proc-14810))
-                     (body-14888
-                       (let ((fun-exp-14892
-                               (make-struct/no-tail
-                                 (vector-ref %expanded-vtables 3)
-                                 src-14801
-                                 f-name-14807
-                                 f-14806)))
-                         (make-struct/no-tail
-                           (vector-ref %expanded-vtables 11)
-                           src-14801
-                           fun-exp-14892
-                           val-exps-14804))))
-                 (make-struct/no-tail
-                   (vector-ref %expanded-vtables 16)
-                   src-14801
-                   #f
-                   names-14885
-                   gensyms-14886
-                   vals-14887
-                   body-14888)))))))
-     (build-letrec-4245
-       (lambda (src-14908
-                in-order?-14909
-                ids-14910
-                vars-14911
-                val-exps-14912
-                body-exp-14913)
-         (if (null? vars-14911)
-           body-exp-14913
-           (begin
-             (for-each
-               maybe-name-value!-4226
-               ids-14910
-               val-exps-14912)
-             (make-struct/no-tail
-               (vector-ref %expanded-vtables 16)
-               src-14908
-               in-order?-14909
-               ids-14910
-               vars-14911
-               val-exps-14912
-               body-exp-14913)))))
-     (extend-env-4255
-       (lambda (labels-14939 bindings-14940 r-14941)
-         (if (null? labels-14939)
-           r-14941
-           (extend-env-4255
-             (cdr labels-14939)
-             (cdr bindings-14940)
-             (cons (cons (car labels-14939) (car bindings-14940))
-                   r-14941)))))
-     (extend-var-env-4256
-       (lambda (labels-14942 vars-14943 r-14944)
-         (if (null? labels-14942)
-           r-14944
-           (extend-var-env-4256
-             (cdr labels-14942)
-             (cdr vars-14943)
-             (cons (cons (car labels-14942)
-                         (cons 'lexical (car vars-14943)))
-                   r-14944)))))
-     (macros-only-env-4257
-       (lambda (r-14945)
-         (if (null? r-14945)
-           '()
-           (let ((a-14946 (car r-14945)))
-             (if (eq? (car (cdr a-14946)) 'macro)
-               (cons a-14946
-                     (macros-only-env-4257 (cdr r-14945)))
-               (macros-only-env-4257 (cdr r-14945)))))))
-     (global-extend-4259
-       (lambda (type-14948 sym-14949 val-14950)
-         (module-define!
-           (current-module)
-           sym-14949
-           (make-syntax-transformer
-             sym-14949
-             type-14948
-             val-14950))))
-     (id?-4261
-       (lambda (x-9380)
-         (if (symbol? x-9380)
-           #t
-           (if (if (vector? x-9380)
-                 (if (= (vector-length x-9380) 4)
-                   (eq? (vector-ref x-9380 0) 'syntax-object)
-                   #f)
-                 #f)
-             (symbol? (vector-ref x-9380 1))
-             #f))))
-     (gen-labels-4264
-       (lambda (ls-14960)
-         (if (null? ls-14960)
-           '()
-           (cons (string-append
-                   "l-"
-                   (session-id-4222)
-                   (symbol->string (gensym "-")))
-                 (gen-labels-4264 (cdr ls-14960))))))
-     (make-binding-wrap-4275
-       (lambda (ids-14964 labels-14965 w-14966)
-         (if (null? ids-14964)
-           w-14966
-           (cons (car w-14966)
-                 (cons (let ((labelvec-14967 (list->vector labels-14965)))
-                         (let ((n-14968 (vector-length labelvec-14967)))
-                           (let ((symnamevec-14969 (make-vector n-14968))
-                                 (marksvec-14970 (make-vector n-14968)))
-                             (begin
-                               (letrec*
-                                 ((f-14971
-                                    (lambda (ids-14974 i-14975)
-                                      (if (not (null? ids-14974))
-                                        (call-with-values
-                                          (lambda ()
-                                            (let ((x-14978 (car ids-14974)))
-                                              (if (if (vector? x-14978)
-                                                    (if (= (vector-length
-                                                             x-14978)
-                                                           4)
-                                                      (eq? (vector-ref
-                                                             x-14978
-                                                             0)
-                                                           'syntax-object)
-                                                      #f)
-                                                    #f)
-                                                (values
-                                                  (vector-ref x-14978 1)
-                                                  (let ((m1-14994
-                                                          (car w-14966))
-                                                        (m2-14995
-                                                          (car (vector-ref
-                                                                 x-14978
-                                                                 2))))
-                                                    (if (null? m2-14995)
-                                                      m1-14994
-                                                      (append
-                                                        m1-14994
-                                                        m2-14995))))
-                                                (values
-                                                  x-14978
-                                                  (car w-14966)))))
-                                          (lambda (symname-15015 marks-15016)
-                                            (begin
-                                              (vector-set!
-                                                symnamevec-14969
-                                                i-14975
-                                                symname-15015)
-                                              (vector-set!
-                                                marksvec-14970
-                                                i-14975
-                                                marks-15016)
-                                              (f-14971
-                                                (cdr ids-14974)
-                                                (#{1+}# i-14975)))))))))
-                                 (f-14971 ids-14964 0))
-                               (vector
-                                 'ribcage
-                                 symnamevec-14969
-                                 marksvec-14970
-                                 labelvec-14967)))))
-                       (cdr w-14966))))))
-     (join-wraps-4277
-       (lambda (w1-15025 w2-15026)
-         (let ((m1-15027 (car w1-15025))
-               (s1-15028 (cdr w1-15025)))
-           (if (null? m1-15027)
-             (if (null? s1-15028)
-               w2-15026
-               (cons (car w2-15026)
-                     (let ((m2-15035 (cdr w2-15026)))
-                       (if (null? m2-15035)
-                         s1-15028
-                         (append s1-15028 m2-15035)))))
-             (cons (let ((m2-15044 (car w2-15026)))
-                     (if (null? m2-15044)
-                       m1-15027
-                       (append m1-15027 m2-15044)))
-                   (let ((m2-15053 (cdr w2-15026)))
-                     (if (null? m2-15053)
-                       s1-15028
-                       (append s1-15028 m2-15053))))))))
-     (same-marks?-4279
-       (lambda (x-15058 y-15059)
-         (if (eq? x-15058 y-15059)
-           (eq? x-15058 y-15059)
-           (if (not (null? x-15058))
-             (if (not (null? y-15059))
-               (if (eq? (car x-15058) (car y-15059))
-                 (same-marks?-4279 (cdr x-15058) (cdr y-15059))
-                 #f)
-               #f)
-             #f))))
-     (id-var-name-4280
-       (lambda (id-15067 w-15068)
-         (letrec*
-           ((search-15069
-              (lambda (sym-15130 subst-15131 marks-15132)
-                (if (null? subst-15131)
-                  (values #f marks-15132)
-                  (let ((fst-15133 (car subst-15131)))
-                    (if (eq? fst-15133 'shift)
-                      (search-15069
-                        sym-15130
-                        (cdr subst-15131)
-                        (cdr marks-15132))
-                      (let ((symnames-15135 (vector-ref fst-15133 1)))
-                        (if (vector? symnames-15135)
-                          (let ((n-15147 (vector-length symnames-15135)))
-                            (letrec*
-                              ((f-15148
-                                 (lambda (i-15150)
-                                   (if (= i-15150 n-15147)
-                                     (search-15069
-                                       sym-15130
-                                       (cdr subst-15131)
-                                       marks-15132)
-                                     (if (if (eq? (vector-ref
-                                                    symnames-15135
-                                                    i-15150)
-                                                  sym-15130)
-                                           (same-marks?-4279
-                                             marks-15132
-                                             (vector-ref
-                                               (vector-ref fst-15133 2)
-                                               i-15150))
-                                           #f)
-                                       (values
-                                         (vector-ref
-                                           (vector-ref fst-15133 3)
-                                           i-15150)
-                                         marks-15132)
-                                       (f-15148 (#{1+}# i-15150)))))))
-                              (f-15148 0)))
-                          (letrec*
-                            ((f-15183
-                               (lambda (symnames-15185 i-15186)
-                                 (if (null? symnames-15185)
-                                   (search-15069
-                                     sym-15130
-                                     (cdr subst-15131)
-                                     marks-15132)
-                                   (if (if (eq? (car symnames-15185) sym-15130)
-                                         (same-marks?-4279
-                                           marks-15132
-                                           (list-ref
-                                             (vector-ref fst-15133 2)
-                                             i-15186))
-                                         #f)
-                                     (values
-                                       (list-ref
-                                         (vector-ref fst-15133 3)
-                                         i-15186)
-                                       marks-15132)
-                                     (f-15183
-                                       (cdr symnames-15185)
-                                       (#{1+}# i-15186)))))))
-                            (f-15183 symnames-15135 0))))))))))
-           (if (symbol? id-15067)
-             (let ((t-15072
-                     (search-15069
-                       id-15067
-                       (cdr w-15068)
-                       (car w-15068))))
-               (if t-15072 t-15072 id-15067))
-             (if (if (vector? id-15067)
-                   (if (= (vector-length id-15067) 4)
-                     (eq? (vector-ref id-15067 0) 'syntax-object)
-                     #f)
-                   #f)
-               (let ((id-15087 (vector-ref id-15067 1))
-                     (w1-15088 (vector-ref id-15067 2)))
-                 (let ((marks-15089
-                         (let ((m1-15099 (car w-15068))
-                               (m2-15100 (car w1-15088)))
-                           (if (null? m2-15100)
-                             m1-15099
-                             (append m1-15099 m2-15100)))))
-                   (call-with-values
-                     (lambda ()
-                       (search-15069 id-15087 (cdr w-15068) marks-15089))
-                     (lambda (new-id-15116 marks-15117)
-                       (if new-id-15116
-                         new-id-15116
-                         (let ((t-15125
-                                 (search-15069
-                                   id-15087
-                                   (cdr w1-15088)
-                                   marks-15117)))
-                           (if t-15125 t-15125 id-15087)))))))
-               (syntax-violation
-                 'id-var-name
-                 "invalid id"
-                 id-15067))))))
-     (locally-bound-identifiers-4281
-       (lambda (w-15208 mod-15209)
-         (letrec*
-           ((scan-15210
-              (lambda (subst-15215 results-15216)
-                (if (null? subst-15215)
-                  results-15216
-                  (let ((fst-15217 (car subst-15215)))
-                    (if (eq? fst-15217 'shift)
-                      (scan-15210 (cdr subst-15215) results-15216)
-                      (let ((symnames-15219 (vector-ref fst-15217 1))
-                            (marks-15220 (vector-ref fst-15217 2)))
-                        (if (vector? symnames-15219)
-                          (scan-vector-rib-15212
-                            subst-15215
-                            symnames-15219
-                            marks-15220
-                            results-15216)
-                          (scan-list-rib-15211
-                            subst-15215
-                            symnames-15219
-                            marks-15220
-                            results-15216))))))))
-            (scan-list-rib-15211
-              (lambda (subst-15318
-                       symnames-15319
-                       marks-15320
-                       results-15321)
-                (letrec*
-                  ((f-15322
-                     (lambda (symnames-15422 marks-15423 results-15424)
-                       (if (null? symnames-15422)
-                         (scan-15210 (cdr subst-15318) results-15424)
-                         (f-15322
-                           (cdr symnames-15422)
-                           (cdr marks-15423)
-                           (cons (wrap-4290
-                                   (car symnames-15422)
-                                   (let ((w-15432
-                                           (cons (car marks-15423)
-                                                 subst-15318)))
-                                     (cons (cons #f (car w-15432))
-                                           (cons 'shift (cdr w-15432))))
-                                   mod-15209)
-                                 results-15424))))))
-                  (f-15322
-                    symnames-15319
-                    marks-15320
-                    results-15321))))
-            (scan-vector-rib-15212
-              (lambda (subst-15433
-                       symnames-15434
-                       marks-15435
-                       results-15436)
-                (let ((n-15437 (vector-length symnames-15434)))
-                  (letrec*
-                    ((f-15438
-                       (lambda (i-15521 results-15522)
-                         (if (= i-15521 n-15437)
-                           (scan-15210 (cdr subst-15433) results-15522)
-                           (f-15438
-                             (#{1+}# i-15521)
-                             (cons (wrap-4290
-                                     (vector-ref symnames-15434 i-15521)
-                                     (let ((w-15530
-                                             (cons (vector-ref
-                                                     marks-15435
-                                                     i-15521)
-                                                   subst-15433)))
-                                       (cons (cons #f (car w-15530))
-                                             (cons 'shift (cdr w-15530))))
-                                     mod-15209)
-                                   results-15522))))))
-                    (f-15438 0 results-15436))))))
-           (scan-15210 (cdr w-15208) '()))))
-     (valid-bound-ids?-4287
-       (lambda (ids-15531)
-         (if (letrec*
-               ((all-ids?-15532
-                  (lambda (ids-15694)
-                    (if (null? ids-15694)
-                      (null? ids-15694)
-                      (if (let ((x-15705 (car ids-15694)))
-                            (if (symbol? x-15705)
-                              #t
-                              (if (if (vector? x-15705)
-                                    (if (= (vector-length x-15705) 4)
-                                      (eq? (vector-ref x-15705 0)
-                                           'syntax-object)
-                                      #f)
-                                    #f)
-                                (symbol? (vector-ref x-15705 1))
-                                #f)))
-                        (all-ids?-15532 (cdr ids-15694))
-                        #f)))))
-               (all-ids?-15532 ids-15531))
-           (distinct-bound-ids?-4288 ids-15531)
-           #f)))
-     (distinct-bound-ids?-4288
-       (lambda (ids-15833)
-         (letrec*
-           ((distinct?-15834
-              (lambda (ids-15946)
-                (if (null? ids-15946)
-                  (null? ids-15946)
-                  (if (not (bound-id-member?-4289
-                             (car ids-15946)
-                             (cdr ids-15946)))
-                    (distinct?-15834 (cdr ids-15946))
-                    #f)))))
-           (distinct?-15834 ids-15833))))
-     (bound-id-member?-4289
-       (lambda (x-16156 list-16157)
-         (if (not (null? list-16157))
-           (let ((t-16158
-                   (let ((j-16239 (car list-16157)))
-                     (if (if (if (vector? x-16156)
-                               (if (= (vector-length x-16156) 4)
-                                 (eq? (vector-ref x-16156 0) 'syntax-object)
-                                 #f)
-                               #f)
-                           (if (vector? j-16239)
-                             (if (= (vector-length j-16239) 4)
-                               (eq? (vector-ref j-16239 0) 'syntax-object)
-                               #f)
-                             #f)
-                           #f)
-                       (if (eq? (vector-ref x-16156 1)
-                                (vector-ref j-16239 1))
-                         (same-marks?-4279
-                           (car (vector-ref x-16156 2))
-                           (car (vector-ref j-16239 2)))
-                         #f)
-                       (eq? x-16156 j-16239)))))
-             (if t-16158
-               t-16158
-               (bound-id-member?-4289 x-16156 (cdr list-16157))))
-           #f)))
-     (wrap-4290
-       (lambda (x-16283 w-16284 defmod-16285)
-         (if (if (null? (car w-16284))
-               (null? (cdr w-16284))
-               #f)
-           x-16283
-           (if (if (vector? x-16283)
-                 (if (= (vector-length x-16283) 4)
-                   (eq? (vector-ref x-16283 0) 'syntax-object)
-                   #f)
-                 #f)
-             (let ((expression-16299 (vector-ref x-16283 1))
-                   (wrap-16300
-                     (join-wraps-4277 w-16284 (vector-ref x-16283 2)))
-                   (module-16301 (vector-ref x-16283 3)))
-               (vector
-                 'syntax-object
-                 expression-16299
-                 wrap-16300
-                 module-16301))
-             (if (null? x-16283)
-               x-16283
-               (vector
-                 'syntax-object
-                 x-16283
-                 w-16284
-                 defmod-16285))))))
-     (source-wrap-4291
-       (lambda (x-16318 w-16319 s-16320 defmod-16321)
-         (wrap-4290
-           (begin
-             (if (if s-16320
-                   (supports-source-properties? x-16318)
-                   #f)
-               (set-source-properties! x-16318 s-16320))
-             x-16318)
-           w-16319
-           defmod-16321)))
-     (expand-sequence-4292
-       (lambda (body-24664 r-24665 w-24666 s-24667 mod-24668)
-         (build-sequence-4242
-           s-24667
-           (letrec*
-             ((dobody-24791
-                (lambda (body-25066 r-25067 w-25068 mod-25069)
-                  (if (null? body-25066)
-                    '()
-                    (let ((first-25070
-                            (let ((e-25120 (car body-25066)))
-                              (call-with-values
-                                (lambda ()
-                                  (syntax-type-4296
-                                    e-25120
-                                    r-25067
-                                    w-25068
-                                    (let ((props-25130
-                                            (source-properties
-                                              (if (if (vector? e-25120)
-                                                    (if (= (vector-length
-                                                             e-25120)
-                                                           4)
-                                                      (eq? (vector-ref
-                                                             e-25120
-                                                             0)
-                                                           'syntax-object)
-                                                      #f)
-                                                    #f)
-                                                (vector-ref e-25120 1)
-                                                e-25120))))
-                                      (if (pair? props-25130) props-25130 #f))
-                                    #f
-                                    mod-25069
-                                    #f))
-                                (lambda (type-25153
-                                         value-25154
-                                         form-25155
-                                         e-25156
-                                         w-25157
-                                         s-25158
-                                         mod-25159)
-                                  (expand-expr-4298
-                                    type-25153
-                                    value-25154
-                                    form-25155
-                                    e-25156
-                                    r-25067
-                                    w-25157
-                                    s-25158
-                                    mod-25159))))))
-                      (cons first-25070
-                            (dobody-24791
-                              (cdr body-25066)
-                              r-25067
-                              w-25068
-                              mod-25069)))))))
-             (dobody-24791
-               body-24664
-               r-24665
-               w-24666
-               mod-24668)))))
-     (expand-top-sequence-4293
-       (lambda (body-16339
-                r-16340
-                w-16341
-                s-16342
-                m-16343
-                esew-16344
-                mod-16345)
-         (letrec*
-           ((scan-16346
-              (lambda (body-16477
-                       r-16478
-                       w-16479
-                       s-16480
-                       m-16481
-                       esew-16482
-                       mod-16483
-                       exps-16484)
-                (if (null? body-16477)
-                  exps-16484
-                  (call-with-values
-                    (lambda ()
-                      (call-with-values
-                        (lambda ()
-                          (let ((e-16485 (car body-16477)))
-                            (syntax-type-4296
-                              e-16485
-                              r-16478
-                              w-16479
-                              (let ((t-16489
-                                      (let ((props-16521
-                                              (source-properties
-                                                (if (if (vector? e-16485)
-                                                      (if (= (vector-length
-                                                               e-16485)
-                                                             4)
-                                                        (eq? (vector-ref
-                                                               e-16485
-                                                               0)
-                                                             'syntax-object)
-                                                        #f)
-                                                      #f)
-                                                  (vector-ref e-16485 1)
-                                                  e-16485))))
-                                        (if (pair? props-16521)
-                                          props-16521
-                                          #f))))
-                                (if t-16489 t-16489 s-16480))
-                              #f
-                              mod-16483
-                              #f)))
-                        (lambda (type-16544
-                                 value-16545
-                                 form-16546
-                                 e-16547
-                                 w-16548
-                                 s-16549
-                                 mod-16550)
-                          (if (eqv? type-16544 'begin-form)
-                            (let ((tmp-16559 ($sc-dispatch e-16547 '(_))))
-                              (if tmp-16559
-                                (@apply (lambda () exps-16484) tmp-16559)
-                                (let ((tmp-16563
-                                        ($sc-dispatch
-                                          e-16547
-                                          '(_ any . each-any))))
-                                  (if tmp-16563
-                                    (@apply
-                                      (lambda (e1-16567 e2-16568)
-                                        (scan-16346
-                                          (cons e1-16567 e2-16568)
-                                          r-16478
-                                          w-16548
-                                          s-16549
-                                          m-16481
-                                          esew-16482
-                                          mod-16550
-                                          exps-16484))
-                                      tmp-16563)
-                                    (syntax-violation
-                                      #f
-                                      "source expression failed to match any 
pattern"
-                                      e-16547)))))
-                            (if (eqv? type-16544 'local-syntax-form)
-                              (expand-local-syntax-4302
-                                value-16545
-                                e-16547
-                                r-16478
-                                w-16548
-                                s-16549
-                                mod-16550
-                                (lambda (body-16586
-                                         r-16587
-                                         w-16588
-                                         s-16589
-                                         mod-16590)
-                                  (scan-16346
-                                    body-16586
-                                    r-16587
-                                    w-16588
-                                    s-16589
-                                    m-16481
-                                    esew-16482
-                                    mod-16590
-                                    exps-16484)))
-                              (if (eqv? type-16544 'eval-when-form)
-                                (let ((tmp-16598
-                                        ($sc-dispatch
-                                          e-16547
-                                          '(_ each-any any . each-any))))
-                                  (if tmp-16598
-                                    (@apply
-                                      (lambda (x-16602 e1-16603 e2-16604)
-                                        (let ((when-list-16605
-                                                (parse-when-list-4295
-                                                  e-16547
-                                                  x-16602))
-                                              (body-16606
-                                                (cons e1-16603 e2-16604)))
-                                          (if (eq? m-16481 'e)
-                                            (if (memq 'eval when-list-16605)
-                                              (scan-16346
-                                                body-16606
-                                                r-16478
-                                                w-16548
-                                                s-16549
-                                                (if (memq 'expand
-                                                          when-list-16605)
-                                                  'c&e
-                                                  'e)
-                                                '(eval)
-                                                mod-16550
-                                                exps-16484)
-                                              (begin
-                                                (if (memq 'expand
-                                                          when-list-16605)
-                                                  (let ((x-16683
-                                                          
(expand-top-sequence-4293
-                                                            body-16606
-                                                            r-16478
-                                                            w-16548
-                                                            s-16549
-                                                            'e
-                                                            '(eval)
-                                                            mod-16550)))
-                                                    (primitive-eval x-16683)))
-                                                exps-16484))
-                                            (if (memq 'load when-list-16605)
-                                              (if (let ((t-16709
-                                                          (memq 'compile
-                                                                
when-list-16605)))
-                                                    (if t-16709
-                                                      t-16709
-                                                      (let ((t-16758
-                                                              (memq 'expand
-                                                                    
when-list-16605)))
-                                                        (if t-16758
-                                                          t-16758
-                                                          (if (eq? m-16481
-                                                                   'c&e)
-                                                            (memq 'eval
-                                                                  
when-list-16605)
-                                                            #f)))))
-                                                (scan-16346
-                                                  body-16606
-                                                  r-16478
-                                                  w-16548
-                                                  s-16549
-                                                  'c&e
-                                                  '(compile load)
-                                                  mod-16550
-                                                  exps-16484)
-                                                (if (if (eq? m-16481 'c)
-                                                      #t
-                                                      (eq? m-16481 'c&e))
-                                                  (scan-16346
-                                                    body-16606
-                                                    r-16478
-                                                    w-16548
-                                                    s-16549
-                                                    'c
-                                                    '(load)
-                                                    mod-16550
-                                                    exps-16484)
-                                                  exps-16484))
-                                              (if (let ((t-16887
-                                                          (memq 'compile
-                                                                
when-list-16605)))
-                                                    (if t-16887
-                                                      t-16887
-                                                      (let ((t-16936
-                                                              (memq 'expand
-                                                                    
when-list-16605)))
-                                                        (if t-16936
-                                                          t-16936
-                                                          (if (eq? m-16481
-                                                                   'c&e)
-                                                            (memq 'eval
-                                                                  
when-list-16605)
-                                                            #f)))))
-                                                (begin
-                                                  (let ((x-17060
-                                                          
(expand-top-sequence-4293
-                                                            body-16606
-                                                            r-16478
-                                                            w-16548
-                                                            s-16549
-                                                            'e
-                                                            '(eval)
-                                                            mod-16550)))
-                                                    (primitive-eval x-17060))
-                                                  exps-16484)
-                                                exps-16484)))))
-                                      tmp-16598)
-                                    (syntax-violation
-                                      #f
-                                      "source expression failed to match any 
pattern"
-                                      e-16547)))
-                                (if (if (eqv? type-16544 'define-syntax-form)
-                                      #t
-                                      (eqv? type-16544
-                                            'define-syntax-parameter-form))
-                                  (let ((n-17109
-                                          (id-var-name-4280
-                                            value-16545
-                                            w-16548))
-                                        (r-17110
-                                          (macros-only-env-4257 r-16478)))
-                                    (if (eqv? m-16481 'c)
-                                      (if (memq 'compile esew-16482)
-                                        (let ((e-17118
-                                                (expand-install-global-4294
-                                                  n-17109
-                                                  (call-with-values
-                                                    (lambda ()
-                                                      (syntax-type-4296
-                                                        e-16547
-                                                        r-17110
-                                                        w-16548
-                                                        (let ((props-17391
-                                                                
(source-properties
-                                                                  (if (if 
(vector?
-                                                                            
e-16547)
-                                                                        (if (= 
(vector-length
-                                                                               
  e-16547)
-                                                                               
4)
-                                                                          (eq? 
(vector-ref
-                                                                               
  e-16547
-                                                                               
  0)
-                                                                               
'syntax-object)
-                                                                          #f)
-                                                                        #f)
-                                                                    (vector-ref
-                                                                      e-16547
-                                                                      1)
-                                                                    e-16547))))
-                                                          (if (pair? 
props-17391)
-                                                            props-17391
-                                                            #f))
-                                                        #f
-                                                        mod-16550
-                                                        #f))
-                                                    (lambda (type-17424
-                                                             value-17425
-                                                             form-17426
-                                                             e-17427
-                                                             w-17428
-                                                             s-17429
-                                                             mod-17430)
-                                                      (expand-expr-4298
-                                                        type-17424
-                                                        value-17425
-                                                        form-17426
-                                                        e-17427
-                                                        r-17110
-                                                        w-17428
-                                                        s-17429
-                                                        mod-17430))))))
-                                          (begin
-                                            (top-level-eval-hook-4220
-                                              e-17118
-                                              mod-16550)
-                                            (if (memq 'load esew-16482)
-                                              (cons e-17118 exps-16484)
-                                              exps-16484)))
-                                        (if (memq 'load esew-16482)
-                                          (cons (expand-install-global-4294
-                                                  n-17109
-                                                  (call-with-values
-                                                    (lambda ()
-                                                      (syntax-type-4296
-                                                        e-16547
-                                                        r-17110
-                                                        w-16548
-                                                        (let ((props-17660
-                                                                
(source-properties
-                                                                  (if (if 
(vector?
-                                                                            
e-16547)
-                                                                        (if (= 
(vector-length
-                                                                               
  e-16547)
-                                                                               
4)
-                                                                          (eq? 
(vector-ref
-                                                                               
  e-16547
-                                                                               
  0)
-                                                                               
'syntax-object)
-                                                                          #f)
-                                                                        #f)
-                                                                    (vector-ref
-                                                                      e-16547
-                                                                      1)
-                                                                    e-16547))))
-                                                          (if (pair? 
props-17660)
-                                                            props-17660
-                                                            #f))
-                                                        #f
-                                                        mod-16550
-                                                        #f))
-                                                    (lambda (type-17662
-                                                             value-17663
-                                                             form-17664
-                                                             e-17665
-                                                             w-17666
-                                                             s-17667
-                                                             mod-17668)
-                                                      (expand-expr-4298
-                                                        type-17662
-                                                        value-17663
-                                                        form-17664
-                                                        e-17665
-                                                        r-17110
-                                                        w-17666
-                                                        s-17667
-                                                        mod-17668))))
-                                                exps-16484)
-                                          exps-16484))
-                                      (if (eqv? m-16481 'c&e)
-                                        (let ((e-17677
-                                                (expand-install-global-4294
-                                                  n-17109
-                                                  (call-with-values
-                                                    (lambda ()
-                                                      (syntax-type-4296
-                                                        e-16547
-                                                        r-17110
-                                                        w-16548
-                                                        (let ((props-17949
-                                                                
(source-properties
-                                                                  (if (if 
(vector?
-                                                                            
e-16547)
-                                                                        (if (= 
(vector-length
-                                                                               
  e-16547)
-                                                                               
4)
-                                                                          (eq? 
(vector-ref
-                                                                               
  e-16547
-                                                                               
  0)
-                                                                               
'syntax-object)
-                                                                          #f)
-                                                                        #f)
-                                                                    (vector-ref
-                                                                      e-16547
-                                                                      1)
-                                                                    e-16547))))
-                                                          (if (pair? 
props-17949)
-                                                            props-17949
-                                                            #f))
-                                                        #f
-                                                        mod-16550
-                                                        #f))
-                                                    (lambda (type-17982
-                                                             value-17983
-                                                             form-17984
-                                                             e-17985
-                                                             w-17986
-                                                             s-17987
-                                                             mod-17988)
-                                                      (expand-expr-4298
-                                                        type-17982
-                                                        value-17983
-                                                        form-17984
-                                                        e-17985
-                                                        r-17110
-                                                        w-17986
-                                                        s-17987
-                                                        mod-17988))))))
-                                          (begin
-                                            (top-level-eval-hook-4220
-                                              e-17677
-                                              mod-16550)
-                                            (cons e-17677 exps-16484)))
-                                        (begin
-                                          (if (memq 'eval esew-16482)
-                                            (top-level-eval-hook-4220
-                                              (let ((e-18087
-                                                      (call-with-values
-                                                        (lambda ()
-                                                          (syntax-type-4296
-                                                            e-16547
-                                                            r-17110
-                                                            w-16548
-                                                            (let ((props-18152
-                                                                    
(source-properties
-                                                                      (if (if 
(vector?
-                                                                               
 e-16547)
-                                                                            
(if (= (vector-length
-                                                                               
      e-16547)
-                                                                               
    4)
-                                                                              
(eq? (vector-ref
-                                                                               
      e-16547
-                                                                               
      0)
-                                                                               
    'syntax-object)
-                                                                              
#f)
-                                                                            #f)
-                                                                        
(vector-ref
-                                                                          
e-16547
-                                                                          1)
-                                                                        
e-16547))))
-                                                              (if (pair? 
props-18152)
-                                                                props-18152
-                                                                #f))
-                                                            #f
-                                                            mod-16550
-                                                            #f))
-                                                        (lambda (type-18185
-                                                                 value-18186
-                                                                 form-18187
-                                                                 e-18188
-                                                                 w-18189
-                                                                 s-18190
-                                                                 mod-18191)
-                                                          (expand-expr-4298
-                                                            type-18185
-                                                            value-18186
-                                                            form-18187
-                                                            e-18188
-                                                            r-17110
-                                                            w-18189
-                                                            s-18190
-                                                            mod-18191)))))
-                                                (let ((exp-18092
-                                                        (let ((fun-exp-18102
-                                                                (if (equal?
-                                                                      
(module-name
-                                                                        
(current-module))
-                                                                      '(guile))
-                                                                  
(make-struct/no-tail
-                                                                    (vector-ref
-                                                                      
%expanded-vtables
-                                                                      7)
-                                                                    #f
-                                                                    
'make-syntax-transformer)
-                                                                  
(make-struct/no-tail
-                                                                    (vector-ref
-                                                                      
%expanded-vtables
-                                                                      5)
-                                                                    #f
-                                                                    '(guile)
-                                                                    
'make-syntax-transformer
-                                                                    #f)))
-                                                              (arg-exps-18103
-                                                                (list 
(make-struct/no-tail
-                                                                        
(vector-ref
-                                                                          
%expanded-vtables
-                                                                          1)
-                                                                        #f
-                                                                        
n-17109)
-                                                                      
(make-struct/no-tail
-                                                                        
(vector-ref
-                                                                          
%expanded-vtables
-                                                                          1)
-                                                                        #f
-                                                                        'macro)
-                                                                      
e-18087)))
-                                                          (make-struct/no-tail
-                                                            (vector-ref
-                                                              %expanded-vtables
-                                                              11)
-                                                            #f
-                                                            fun-exp-18102
-                                                            arg-exps-18103))))
-                                                  (begin
-                                                    (if (if (struct? exp-18092)
-                                                          (eq? (struct-vtable
-                                                                 exp-18092)
-                                                               (vector-ref
-                                                                 
%expanded-vtables
-                                                                 13))
-                                                          #f)
-                                                      (let ((meta-18203
-                                                              (struct-ref
-                                                                exp-18092
-                                                                1)))
-                                                        (if (not (assq 'name
-                                                                       
meta-18203))
-                                                          (let ((v-18210
-                                                                  (cons (cons 
'name
-                                                                              
n-17109)
-                                                                        
meta-18203)))
-                                                            (struct-set!
-                                                              exp-18092
-                                                              1
-                                                              v-18210)))))
-                                                    (make-struct/no-tail
-                                                      (vector-ref
-                                                        %expanded-vtables
-                                                        9)
-                                                      #f
-                                                      n-17109
-                                                      exp-18092))))
-                                              mod-16550))
-                                          exps-16484))))
-                                  (if (eqv? type-16544 'define-form)
-                                    (let ((n-18293
-                                            (id-var-name-4280
-                                              value-16545
-                                              w-16548)))
-                                      (let ((type-18294
-                                              (car (let ((t-18302
-                                                           (assq n-18293
-                                                                 r-16478)))
-                                                     (if t-18302
-                                                       (cdr t-18302)
-                                                       (if (symbol? n-18293)
-                                                         (let ((t-18308
-                                                                 
(get-global-definition-hook-4224
-                                                                   n-18293
-                                                                   mod-16550)))
-                                                           (if t-18308
-                                                             t-18308
-                                                             '(global)))
-                                                         
'(displaced-lexical)))))))
-                                        (if (if (eqv? type-18294 'global)
-                                              #t
-                                              (if (eqv? type-18294 'core)
-                                                #t
-                                                (if (eqv? type-18294 'macro)
-                                                  #t
-                                                  (eqv? type-18294
-                                                        'module-ref))))
-                                          (begin
-                                            (if (if (if (eq? m-16481 'c)
-                                                      #t
-                                                      (eq? m-16481 'c&e))
-                                                  (if (not 
(module-local-variable
-                                                             (current-module)
-                                                             n-18293))
-                                                    (current-module)
-                                                    #f)
-                                                  #f)
-                                              (let ((old-18341
-                                                      (module-variable
-                                                        (current-module)
-                                                        n-18293)))
-                                                (if (if (variable? old-18341)
-                                                      (variable-bound?
-                                                        old-18341)
-                                                      #f)
-                                                  (module-define!
-                                                    (current-module)
-                                                    n-18293
-                                                    (variable-ref old-18341))
-                                                  (module-add!
-                                                    (current-module)
-                                                    n-18293
-                                                    
(make-undefined-variable)))))
-                                            (cons (if (eq? m-16481 'c&e)
-                                                    (let ((x-18538
-                                                            (let ((exp-18567
-                                                                    
(call-with-values
-                                                                      (lambda 
()
-                                                                        
(syntax-type-4296
-                                                                          
e-16547
-                                                                          
r-16478
-                                                                          
w-16548
-                                                                          (let 
((props-18570
-                                                                               
   (source-properties
-                                                                               
     (if (if (vector?
-                                                                               
               e-16547)
-                                                                               
           (if (= (vector-length
-                                                                               
                    e-16547)
-                                                                               
                  4)
-                                                                               
             (eq? (vector-ref
-                                                                               
                    e-16547
-                                                                               
                    0)
-                                                                               
                  'syntax-object)
-                                                                               
             #f)
-                                                                               
           #f)
-                                                                               
       (vector-ref
-                                                                               
         e-16547
-                                                                               
         1)
-                                                                               
       e-16547))))
-                                                                            
(if (pair? props-18570)
-                                                                              
props-18570
-                                                                              
#f))
-                                                                          #f
-                                                                          
mod-16550
-                                                                          #f))
-                                                                      (lambda 
(type-18571
-                                                                               
value-18572
-                                                                               
form-18573
-                                                                               
e-18574
-                                                                               
w-18575
-                                                                               
s-18576
-                                                                               
mod-18577)
-                                                                        
(expand-expr-4298
-                                                                          
type-18571
-                                                                          
value-18572
-                                                                          
form-18573
-                                                                          
e-18574
-                                                                          
r-16478
-                                                                          
w-18575
-                                                                          
s-18576
-                                                                          
mod-18577)))))
-                                                              (begin
-                                                                (if (if 
(struct?
-                                                                          
exp-18567)
-                                                                      (eq? 
(struct-vtable
-                                                                             
exp-18567)
-                                                                           
(vector-ref
-                                                                             
%expanded-vtables
-                                                                             
13))
-                                                                      #f)
-                                                                  (let 
((meta-18579
-                                                                          
(struct-ref
-                                                                            
exp-18567
-                                                                            
1)))
-                                                                    (if (not 
(assq 'name
-                                                                               
    meta-18579))
-                                                                      (let 
((v-18581
-                                                                              
(cons (cons 'name
-                                                                               
           n-18293)
-                                                                               
     meta-18579)))
-                                                                        
(struct-set!
-                                                                          
exp-18567
-                                                                          1
-                                                                          
v-18581)))))
-                                                                
(make-struct/no-tail
-                                                                  (vector-ref
-                                                                    
%expanded-vtables
-                                                                    9)
-                                                                  s-16549
-                                                                  n-18293
-                                                                  
exp-18567)))))
-                                                      (begin
-                                                        (primitive-eval
-                                                          x-18538)
-                                                        x-18538))
-                                                    (lambda ()
-                                                      (let ((exp-18583
-                                                              (call-with-values
-                                                                (lambda ()
-                                                                  
(syntax-type-4296
-                                                                    e-16547
-                                                                    r-16478
-                                                                    w-16548
-                                                                    (let 
((props-18586
-                                                                            
(source-properties
-                                                                              
(if (if (vector?
-                                                                               
         e-16547)
-                                                                               
     (if (= (vector-length
-                                                                               
              e-16547)
-                                                                               
            4)
-                                                                               
       (eq? (vector-ref
-                                                                               
              e-16547
-                                                                               
              0)
-                                                                               
            'syntax-object)
-                                                                               
       #f)
-                                                                               
     #f)
-                                                                               
 (vector-ref
-                                                                               
   e-16547
-                                                                               
   1)
-                                                                               
 e-16547))))
-                                                                      (if 
(pair? props-18586)
-                                                                        
props-18586
-                                                                        #f))
-                                                                    #f
-                                                                    mod-16550
-                                                                    #f))
-                                                                (lambda 
(type-18587
-                                                                         
value-18588
-                                                                         
form-18589
-                                                                         
e-18590
-                                                                         
w-18591
-                                                                         
s-18592
-                                                                         
mod-18593)
-                                                                  
(expand-expr-4298
-                                                                    type-18587
-                                                                    value-18588
-                                                                    form-18589
-                                                                    e-18590
-                                                                    r-16478
-                                                                    w-18591
-                                                                    s-18592
-                                                                    
mod-18593)))))
-                                                        (begin
-                                                          (if (if (struct?
-                                                                    exp-18583)
-                                                                (eq? 
(struct-vtable
-                                                                       
exp-18583)
-                                                                     
(vector-ref
-                                                                       
%expanded-vtables
-                                                                       13))
-                                                                #f)
-                                                            (let ((meta-18595
-                                                                    (struct-ref
-                                                                      exp-18583
-                                                                      1)))
-                                                              (if (not (assq 
'name
-                                                                             
meta-18595))
-                                                                (let ((v-18597
-                                                                        (cons 
(cons 'name
-                                                                               
     n-18293)
-                                                                              
meta-18595)))
-                                                                  (struct-set!
-                                                                    exp-18583
-                                                                    1
-                                                                    
v-18597)))))
-                                                          (make-struct/no-tail
-                                                            (vector-ref
-                                                              %expanded-vtables
-                                                              9)
-                                                            s-16549
-                                                            n-18293
-                                                            exp-18583)))))
-                                                  exps-16484))
-                                          (if (eqv? type-18294
-                                                    'displaced-lexical)
-                                            (syntax-violation
-                                              #f
-                                              "identifier out of context"
-                                              (wrap-4290
-                                                (begin
-                                                  (if (if s-16549
-                                                        
(supports-source-properties?
-                                                          form-16546)
-                                                        #f)
-                                                    (set-source-properties!
-                                                      form-16546
-                                                      s-16549))
-                                                  form-16546)
-                                                w-16548
-                                                mod-16550)
-                                              (wrap-4290
-                                                value-16545
-                                                w-16548
-                                                mod-16550))
-                                            (syntax-violation
-                                              #f
-                                              "cannot define keyword at top 
level"
-                                              (wrap-4290
-                                                (begin
-                                                  (if (if s-16549
-                                                        
(supports-source-properties?
-                                                          form-16546)
-                                                        #f)
-                                                    (set-source-properties!
-                                                      form-16546
-                                                      s-16549))
-                                                  form-16546)
-                                                w-16548
-                                                mod-16550)
-                                              (wrap-4290
-                                                value-16545
-                                                w-16548
-                                                mod-16550))))))
-                                    (cons (if (eq? m-16481 'c&e)
-                                            (let ((x-18662
-                                                    (expand-expr-4298
-                                                      type-16544
-                                                      value-16545
-                                                      form-16546
-                                                      e-16547
-                                                      r-16478
-                                                      w-16548
-                                                      s-16549
-                                                      mod-16550)))
-                                              (begin
-                                                (primitive-eval x-18662)
-                                                x-18662))
-                                            (lambda ()
-                                              (expand-expr-4298
-                                                type-16544
-                                                value-16545
-                                                form-16546
-                                                e-16547
-                                                r-16478
-                                                w-16548
-                                                s-16549
-                                                mod-16550)))
-                                          exps-16484)))))))))
-                    (lambda (exps-18667)
-                      (scan-16346
-                        (cdr body-16477)
-                        r-16478
-                        w-16479
-                        s-16480
-                        m-16481
-                        esew-16482
-                        mod-16483
-                        exps-18667)))))))
-           (call-with-values
-             (lambda ()
-               (scan-16346
-                 body-16339
-                 r-16340
-                 w-16341
-                 s-16342
-                 m-16343
-                 esew-16344
-                 mod-16345
-                 '()))
-             (lambda (exps-16349)
-               (if (null? exps-16349)
-                 (make-struct/no-tail
-                   (vector-ref %expanded-vtables 0)
-                   s-16342)
-                 (build-sequence-4242
-                   s-16342
-                   (letrec*
-                     ((lp-16389
-                        (lambda (in-16473 out-16474)
-                          (if (null? in-16473)
-                            out-16474
-                            (let ((e-16475 (car in-16473)))
-                              (lp-16389
-                                (cdr in-16473)
-                                (cons (if (procedure? e-16475)
-                                        (e-16475)
-                                        e-16475)
-                                      out-16474)))))))
-                     (lp-16389 exps-16349 '())))))))))
-     (expand-install-global-4294
-       (lambda (name-18668 e-18669)
-         (let ((exp-18675
-                 (let ((fun-exp-18685
-                         (if (equal? (module-name (current-module)) '(guile))
-                           (make-struct/no-tail
-                             (vector-ref %expanded-vtables 7)
-                             #f
-                             'make-syntax-transformer)
-                           (make-struct/no-tail
-                             (vector-ref %expanded-vtables 5)
-                             #f
-                             '(guile)
-                             'make-syntax-transformer
-                             #f)))
-                       (arg-exps-18686
-                         (list (make-struct/no-tail
-                                 (vector-ref %expanded-vtables 1)
-                                 #f
-                                 name-18668)
-                               (make-struct/no-tail
-                                 (vector-ref %expanded-vtables 1)
-                                 #f
-                                 'macro)
-                               e-18669)))
-                   (make-struct/no-tail
-                     (vector-ref %expanded-vtables 11)
-                     #f
-                     fun-exp-18685
-                     arg-exps-18686))))
-           (begin
-             (if (if (struct? exp-18675)
-                   (eq? (struct-vtable exp-18675)
-                        (vector-ref %expanded-vtables 13))
-                   #f)
-               (let ((meta-18727 (struct-ref exp-18675 1)))
-                 (if (not (assq 'name meta-18727))
-                   (let ((v-18734
-                           (cons (cons 'name name-18668) meta-18727)))
-                     (struct-set! exp-18675 1 v-18734)))))
-             (make-struct/no-tail
-               (vector-ref %expanded-vtables 9)
-               #f
-               name-18668
-               exp-18675)))))
-     (parse-when-list-4295
-       (lambda (e-18745 when-list-18746)
-         (let ((result-18747 (strip-4310 when-list-18746 '(()))))
-           (letrec*
-             ((lp-18748
-                (lambda (l-18802)
-                  (if (null? l-18802)
-                    result-18747
-                    (if (let ((t-18804 (car l-18802)))
-                          (if (eq? t-18804 'compile)
-                            #t
-                            (if (eq? t-18804 'load)
-                              #t
-                              (if (eq? t-18804 'eval)
-                                #t
-                                (eq? t-18804 'expand)))))
-                      (lp-18748 (cdr l-18802))
-                      (syntax-violation
-                        'eval-when
-                        "invalid situation"
-                        e-18745
-                        (car l-18802)))))))
-             (lp-18748 result-18747)))))
-     (syntax-type-4296
-       (lambda (e-18806
-                r-18807
-                w-18808
-                s-18809
-                rib-18810
-                mod-18811
-                for-car?-18812)
-         (if (symbol? e-18806)
-           (let ((n-18813 (id-var-name-4280 e-18806 w-18808)))
-             (let ((b-18814
-                     (let ((t-18823 (assq n-18813 r-18807)))
-                       (if t-18823
-                         (cdr t-18823)
-                         (if (symbol? n-18813)
-                           (let ((t-18829
-                                   (get-global-definition-hook-4224
-                                     n-18813
-                                     mod-18811)))
-                             (if t-18829 t-18829 '(global)))
-                           '(displaced-lexical))))))
-               (let ((type-18815 (car b-18814)))
-                 (if (eqv? type-18815 'lexical)
-                   (values
-                     type-18815
-                     (cdr b-18814)
-                     e-18806
-                     e-18806
-                     w-18808
-                     s-18809
-                     mod-18811)
-                   (if (eqv? type-18815 'global)
-                     (values
-                       type-18815
-                       n-18813
-                       e-18806
-                       e-18806
-                       w-18808
-                       s-18809
-                       mod-18811)
-                     (if (eqv? type-18815 'macro)
-                       (if for-car?-18812
-                         (values
-                           type-18815
-                           (cdr b-18814)
-                           e-18806
-                           e-18806
-                           w-18808
-                           s-18809
-                           mod-18811)
-                         (syntax-type-4296
-                           (expand-macro-4300
-                             (cdr b-18814)
-                             e-18806
-                             r-18807
-                             w-18808
-                             s-18809
-                             rib-18810
-                             mod-18811)
-                           r-18807
-                           '(())
-                           s-18809
-                           rib-18810
-                           mod-18811
-                           #f))
-                       (values
-                         type-18815
-                         (cdr b-18814)
-                         e-18806
-                         e-18806
-                         w-18808
-                         s-18809
-                         mod-18811)))))))
-           (if (pair? e-18806)
-             (let ((first-18857 (car e-18806)))
-               (call-with-values
-                 (lambda ()
-                   (syntax-type-4296
-                     first-18857
-                     r-18807
-                     w-18808
-                     s-18809
-                     rib-18810
-                     mod-18811
-                     #t))
-                 (lambda (ftype-18859
-                          fval-18860
-                          fform-18861
-                          fe-18862
-                          fw-18863
-                          fs-18864
-                          fmod-18865)
-                   (if (eqv? ftype-18859 'lexical)
-                     (values
-                       'lexical-call
-                       fval-18860
-                       e-18806
-                       e-18806
-                       w-18808
-                       s-18809
-                       mod-18811)
-                     (if (eqv? ftype-18859 'global)
-                       (values
-                         'global-call
-                         (vector
-                           'syntax-object
-                           fval-18860
-                           w-18808
-                           fmod-18865)
-                         e-18806
-                         e-18806
-                         w-18808
-                         s-18809
-                         mod-18811)
-                       (if (eqv? ftype-18859 'macro)
-                         (syntax-type-4296
-                           (expand-macro-4300
-                             fval-18860
-                             e-18806
-                             r-18807
-                             w-18808
-                             s-18809
-                             rib-18810
-                             mod-18811)
-                           r-18807
-                           '(())
-                           s-18809
-                           rib-18810
-                           mod-18811
-                           for-car?-18812)
-                         (if (eqv? ftype-18859 'module-ref)
-                           (call-with-values
-                             (lambda () (fval-18860 e-18806 r-18807 w-18808))
-                             (lambda (e-18899
-                                      r-18900
-                                      w-18901
-                                      s-18902
-                                      mod-18903)
-                               (syntax-type-4296
-                                 e-18899
-                                 r-18900
-                                 w-18901
-                                 s-18902
-                                 rib-18810
-                                 mod-18903
-                                 for-car?-18812)))
-                           (if (eqv? ftype-18859 'core)
-                             (values
-                               'core-form
-                               fval-18860
-                               e-18806
-                               e-18806
-                               w-18808
-                               s-18809
-                               mod-18811)
-                             (if (eqv? ftype-18859 'local-syntax)
-                               (values
-                                 'local-syntax-form
-                                 fval-18860
-                                 e-18806
-                                 e-18806
-                                 w-18808
-                                 s-18809
-                                 mod-18811)
-                               (if (eqv? ftype-18859 'begin)
-                                 (values
-                                   'begin-form
-                                   #f
-                                   e-18806
-                                   e-18806
-                                   w-18808
-                                   s-18809
-                                   mod-18811)
-                                 (if (eqv? ftype-18859 'eval-when)
-                                   (values
-                                     'eval-when-form
-                                     #f
-                                     e-18806
-                                     e-18806
-                                     w-18808
-                                     s-18809
-                                     mod-18811)
-                                   (if (eqv? ftype-18859 'define)
-                                     (let ((tmp-18935
-                                             ($sc-dispatch
-                                               e-18806
-                                               '(_ any any))))
-                                       (if (if tmp-18935
-                                             (@apply
-                                               (lambda (name-18939 val-18940)
-                                                 (if (symbol? name-18939)
-                                                   #t
-                                                   (if (if (vector? name-18939)
-                                                         (if (= (vector-length
-                                                                  name-18939)
-                                                                4)
-                                                           (eq? (vector-ref
-                                                                  name-18939
-                                                                  0)
-                                                                'syntax-object)
-                                                           #f)
-                                                         #f)
-                                                     (symbol?
-                                                       (vector-ref
-                                                         name-18939
-                                                         1))
-                                                     #f)))
-                                               tmp-18935)
-                                             #f)
-                                         (@apply
-                                           (lambda (name-18967 val-18968)
-                                             (values
-                                               'define-form
-                                               name-18967
-                                               e-18806
-                                               val-18968
-                                               w-18808
-                                               s-18809
-                                               mod-18811))
-                                           tmp-18935)
-                                         (let ((tmp-18969
-                                                 ($sc-dispatch
-                                                   e-18806
-                                                   '(_ (any . any)
-                                                       any
-                                                       .
-                                                       each-any))))
-                                           (if (if tmp-18969
-                                                 (@apply
-                                                   (lambda (name-18973
-                                                            args-18974
-                                                            e1-18975
-                                                            e2-18976)
-                                                     (if (if (symbol?
-                                                               name-18973)
-                                                           #t
-                                                           (if (if (vector?
-                                                                     
name-18973)
-                                                                 (if (= 
(vector-length
-                                                                          
name-18973)
-                                                                        4)
-                                                                   (eq? 
(vector-ref
-                                                                          
name-18973
-                                                                          0)
-                                                                        
'syntax-object)
-                                                                   #f)
-                                                                 #f)
-                                                             (symbol?
-                                                               (vector-ref
-                                                                 name-18973
-                                                                 1))
-                                                             #f))
-                                                       (valid-bound-ids?-4287
-                                                         (letrec*
-                                                           ((lvl-19125
-                                                              (lambda 
(vars-19127
-                                                                       ls-19128
-                                                                       w-19129)
-                                                                (if (pair? 
vars-19127)
-                                                                  (lvl-19125
-                                                                    (cdr 
vars-19127)
-                                                                    (cons 
(wrap-4290
-                                                                            
(car vars-19127)
-                                                                            
w-19129
-                                                                            #f)
-                                                                          
ls-19128)
-                                                                    w-19129)
-                                                                  (if (if 
(symbol?
-                                                                            
vars-19127)
-                                                                        #t
-                                                                        (if 
(if (vector?
-                                                                               
   vars-19127)
-                                                                              
(if (= (vector-length
-                                                                               
        vars-19127)
-                                                                               
      4)
-                                                                               
 (eq? (vector-ref
-                                                                               
        vars-19127
-                                                                               
        0)
-                                                                               
      'syntax-object)
-                                                                               
 #f)
-                                                                              
#f)
-                                                                          
(symbol?
-                                                                            
(vector-ref
-                                                                              
vars-19127
-                                                                              
1))
-                                                                          #f))
-                                                                    (cons 
(wrap-4290
-                                                                            
vars-19127
-                                                                            
w-19129
-                                                                            #f)
-                                                                          
ls-19128)
-                                                                    (if (null? 
vars-19127)
-                                                                      ls-19128
-                                                                      (if (if 
(vector?
-                                                                               
 vars-19127)
-                                                                            
(if (= (vector-length
-                                                                               
      vars-19127)
-                                                                               
    4)
-                                                                              
(eq? (vector-ref
-                                                                               
      vars-19127
-                                                                               
      0)
-                                                                               
    'syntax-object)
-                                                                              
#f)
-                                                                            #f)
-                                                                        
(lvl-19125
-                                                                          
(vector-ref
-                                                                            
vars-19127
-                                                                            1)
-                                                                          
ls-19128
-                                                                          
(join-wraps-4277
-                                                                            
w-19129
-                                                                            
(vector-ref
-                                                                              
vars-19127
-                                                                              
2)))
-                                                                        (cons 
vars-19127
-                                                                              
ls-19128))))))))
-                                                           (lvl-19125
-                                                             args-18974
-                                                             '()
-                                                             '(()))))
-                                                       #f))
-                                                   tmp-18969)
-                                                 #f)
-                                             (@apply
-                                               (lambda (name-19173
-                                                        args-19174
-                                                        e1-19175
-                                                        e2-19176)
-                                                 (values
-                                                   'define-form
-                                                   (wrap-4290
-                                                     name-19173
-                                                     w-18808
-                                                     mod-18811)
-                                                   (wrap-4290
-                                                     e-18806
-                                                     w-18808
-                                                     mod-18811)
-                                                   (let ((e-19184
-                                                           (cons 
'#(syntax-object
-                                                                    lambda
-                                                                    ((top)
-                                                                     #(ribcage
-                                                                       #(name
-                                                                         args
-                                                                         e1
-                                                                         e2)
-                                                                       #((top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top))
-                                                                       
#("l-*-1902"
-                                                                         
"l-*-1903"
-                                                                         
"l-*-1904"
-                                                                         
"l-*-1905"))
-                                                                     #(ribcage
-                                                                       ()
-                                                                       ()
-                                                                       ())
-                                                                     #(ribcage
-                                                                       #(key)
-                                                                       
#((m-*-1867
-                                                                           
top))
-                                                                       
#("l-*-1868"))
-                                                                     #(ribcage
-                                                                       ()
-                                                                       ()
-                                                                       ())
-                                                                     #(ribcage
-                                                                       ()
-                                                                       ()
-                                                                       ())
-                                                                     #(ribcage
-                                                                       #(ftype
-                                                                         fval
-                                                                         fform
-                                                                         fe
-                                                                         fw
-                                                                         fs
-                                                                         fmod)
-                                                                       #((top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top))
-                                                                       
#("l-*-1860"
-                                                                         
"l-*-1861"
-                                                                         
"l-*-1862"
-                                                                         
"l-*-1863"
-                                                                         
"l-*-1864"
-                                                                         
"l-*-1865"
-                                                                         
"l-*-1866"))
-                                                                     #(ribcage
-                                                                       ()
-                                                                       ()
-                                                                       ())
-                                                                     #(ribcage
-                                                                       #(first)
-                                                                       #((top))
-                                                                       
#("l-*-1851"))
-                                                                     #(ribcage
-                                                                       ()
-                                                                       ()
-                                                                       ())
-                                                                     #(ribcage
-                                                                       ()
-                                                                       ()
-                                                                       ())
-                                                                     #(ribcage
-                                                                       #(e
-                                                                         r
-                                                                         w
-                                                                         s
-                                                                         rib
-                                                                         mod
-                                                                         
for-car?)
-                                                                       #((top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top))
-                                                                       
#("l-*-1827"
-                                                                         
"l-*-1828"
-                                                                         
"l-*-1829"
-                                                                         
"l-*-1830"
-                                                                         
"l-*-1831"
-                                                                         
"l-*-1832"
-                                                                         
"l-*-1833"))
-                                                                     #(ribcage
-                                                                       
(lambda-var-list
-                                                                         
gen-var
-                                                                         strip
-                                                                         
expand-lambda-case
-                                                                         
lambda*-formals
-                                                                         
expand-simple-lambda
-                                                                         
lambda-formals
-                                                                         
ellipsis?
-                                                                         
expand-void
-                                                                         
eval-local-transformer
-                                                                         
expand-local-syntax
-                                                                         
expand-body
-                                                                         
expand-macro
-                                                                         
expand-application
-                                                                         
expand-expr
-                                                                         expand
-                                                                         
syntax-type
-                                                                         
parse-when-list
-                                                                         
expand-install-global
-                                                                         
expand-top-sequence
-                                                                         
expand-sequence
-                                                                         
source-wrap
-                                                                         wrap
-                                                                         
bound-id-member?
-                                                                         
distinct-bound-ids?
-                                                                         
valid-bound-ids?
-                                                                         
bound-id=?
-                                                                         
free-id=?
-                                                                         
with-transformer-environment
-                                                                         
transformer-environment
-                                                                         
resolve-identifier
-                                                                         
locally-bound-identifiers
-                                                                         
id-var-name
-                                                                         
same-marks?
-                                                                         
join-marks
-                                                                         
join-wraps
-                                                                         
smart-append
-                                                                         
make-binding-wrap
-                                                                         
extend-ribcage!
-                                                                         
make-empty-ribcage
-                                                                         
new-mark
-                                                                         
anti-mark
-                                                                         
the-anti-mark
-                                                                         
top-marked?
-                                                                         
top-wrap
-                                                                         
empty-wrap
-                                                                         
set-ribcage-labels!
-                                                                         
set-ribcage-marks!
-                                                                         
set-ribcage-symnames!
-                                                                         
ribcage-labels
-                                                                         
ribcage-marks
-                                                                         
ribcage-symnames
-                                                                         
ribcage?
-                                                                         
make-ribcage
-                                                                         
gen-labels
-                                                                         
gen-label
-                                                                         
make-rename
-                                                                         
rename-marks
-                                                                         
rename-new
-                                                                         
rename-old
-                                                                         
subst-rename?
-                                                                         
wrap-subst
-                                                                         
wrap-marks
-                                                                         
make-wrap
-                                                                         
id-sym-name&marks
-                                                                         
id-sym-name
-                                                                         id?
-                                                                         
nonsymbol-id?
-                                                                         
global-extend
-                                                                         lookup
-                                                                         
macros-only-env
-                                                                         
extend-var-env
-                                                                         
extend-env
-                                                                         
null-env
-                                                                         
binding-value
-                                                                         
binding-type
-                                                                         
make-binding
-                                                                         
arg-check
-                                                                         
source-annotation
-                                                                         
no-source
-                                                                         
set-syntax-object-module!
-                                                                         
set-syntax-object-wrap!
-                                                                         
set-syntax-object-expression!
-                                                                         
syntax-object-module
-                                                                         
syntax-object-wrap
-                                                                         
syntax-object-expression
-                                                                         
syntax-object?
-                                                                         
make-syntax-object
-                                                                         
build-lexical-var
-                                                                         
build-letrec
-                                                                         
build-named-let
-                                                                         
build-let
-                                                                         
build-sequence
-                                                                         
build-data
-                                                                         
build-primref
-                                                                         
build-lambda-case
-                                                                         
build-case-lambda
-                                                                         
build-simple-lambda
-                                                                         
build-global-definition
-                                                                         
build-global-assignment
-                                                                         
build-global-reference
-                                                                         
analyze-variable
-                                                                         
build-lexical-assignment
-                                                                         
build-lexical-reference
-                                                                         
build-dynlet
-                                                                         
build-conditional
-                                                                         
build-application
-                                                                         
build-void
-                                                                         
maybe-name-value!
-                                                                         
decorate-source
-                                                                         
get-global-definition-hook
-                                                                         
put-global-definition-hook
-                                                                         
session-id
-                                                                         
local-eval-hook
-                                                                         
top-level-eval-hook
-                                                                         fx<
-                                                                         fx=
-                                                                         fx-
-                                                                         fx+
-                                                                         
set-lambda-meta!
-                                                                         
lambda-meta
-                                                                         
lambda?
-                                                                         
make-dynlet
-                                                                         
make-letrec
-                                                                         
make-let
-                                                                         
make-lambda-case
-                                                                         
make-lambda
-                                                                         
make-sequence
-                                                                         
make-application
-                                                                         
make-conditional
-                                                                         
make-toplevel-define
-                                                                         
make-toplevel-set
-                                                                         
make-toplevel-ref
-                                                                         
make-module-set
-                                                                         
make-module-ref
-                                                                         
make-lexical-set
-                                                                         
make-lexical-ref
-                                                                         
make-primitive-ref
-                                                                         
make-const
-                                                                         
make-void)
-                                                                       ((top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top)
-                                                                        (top))
-                                                                       
("l-*-476"
-                                                                        
"l-*-474"
-                                                                        
"l-*-472"
-                                                                        
"l-*-470"
-                                                                        
"l-*-468"
-                                                                        
"l-*-466"
-                                                                        
"l-*-464"
-                                                                        
"l-*-462"
-                                                                        
"l-*-460"
-                                                                        
"l-*-458"
-                                                                        
"l-*-456"
-                                                                        
"l-*-454"
-                                                                        
"l-*-452"
-                                                                        
"l-*-450"
-                                                                        
"l-*-448"
-                                                                        
"l-*-446"
-                                                                        
"l-*-444"
-                                                                        
"l-*-442"
-                                                                        
"l-*-440"
-                                                                        
"l-*-438"
-                                                                        
"l-*-436"
-                                                                        
"l-*-434"
-                                                                        
"l-*-432"
-                                                                        
"l-*-430"
-                                                                        
"l-*-428"
-                                                                        
"l-*-426"
-                                                                        
"l-*-424"
-                                                                        
"l-*-422"
-                                                                        
"l-*-420"
-                                                                        
"l-*-418"
-                                                                        
"l-*-416"
-                                                                        
"l-*-414"
-                                                                        
"l-*-412"
-                                                                        
"l-*-410"
-                                                                        
"l-*-408"
-                                                                        
"l-*-406"
-                                                                        
"l-*-404"
-                                                                        
"l-*-402"
-                                                                        
"l-*-400"
-                                                                        
"l-*-399"
-                                                                        
"l-*-397"
-                                                                        
"l-*-394"
-                                                                        
"l-*-393"
-                                                                        
"l-*-392"
-                                                                        
"l-*-390"
-                                                                        
"l-*-389"
-                                                                        
"l-*-387"
-                                                                        
"l-*-385"
-                                                                        
"l-*-383"
-                                                                        
"l-*-381"
-                                                                        
"l-*-379"
-                                                                        
"l-*-377"
-                                                                        
"l-*-375"
-                                                                        
"l-*-373"
-                                                                        
"l-*-370"
-                                                                        
"l-*-368"
-                                                                        
"l-*-367"
-                                                                        
"l-*-365"
-                                                                        
"l-*-363"
-                                                                        
"l-*-361"
-                                                                        
"l-*-359"
-                                                                        
"l-*-358"
-                                                                        
"l-*-357"
-                                                                        
"l-*-356"
-                                                                        
"l-*-354"
-                                                                        
"l-*-353"
-                                                                        
"l-*-350"
-                                                                        
"l-*-348"
-                                                                        
"l-*-346"
-                                                                        
"l-*-344"
-                                                                        
"l-*-342"
-                                                                        
"l-*-340"
-                                                                        
"l-*-338"
-                                                                        
"l-*-337"
-                                                                        
"l-*-336"
-                                                                        
"l-*-334"
-                                                                        
"l-*-332"
-                                                                        
"l-*-331"
-                                                                        
"l-*-328"
-                                                                        
"l-*-327"
-                                                                        
"l-*-325"
-                                                                        
"l-*-323"
-                                                                        
"l-*-321"
-                                                                        
"l-*-319"
-                                                                        
"l-*-317"
-                                                                        
"l-*-315"
-                                                                        
"l-*-313"
-                                                                        
"l-*-311"
-                                                                        
"l-*-309"
-                                                                        
"l-*-306"
-                                                                        
"l-*-304"
-                                                                        
"l-*-302"
-                                                                        
"l-*-300"
-                                                                        
"l-*-298"
-                                                                        
"l-*-296"
-                                                                        
"l-*-294"
-                                                                        
"l-*-292"
-                                                                        
"l-*-290"
-                                                                        
"l-*-288"
-                                                                        
"l-*-286"
-                                                                        
"l-*-284"
-                                                                        
"l-*-282"
-                                                                        
"l-*-280"
-                                                                        
"l-*-278"
-                                                                        
"l-*-276"
-                                                                        
"l-*-274"
-                                                                        
"l-*-272"
-                                                                        
"l-*-270"
-                                                                        
"l-*-268"
-                                                                        
"l-*-266"
-                                                                        
"l-*-264"
-                                                                        
"l-*-262"
-                                                                        
"l-*-260"
-                                                                        
"l-*-258"
-                                                                        
"l-*-256"
-                                                                        
"l-*-255"
-                                                                        
"l-*-254"
-                                                                        
"l-*-253"
-                                                                        
"l-*-252"
-                                                                        
"l-*-250"
-                                                                        
"l-*-248"
-                                                                        
"l-*-246"
-                                                                        
"l-*-243"
-                                                                        
"l-*-241"
-                                                                        
"l-*-239"
-                                                                        
"l-*-237"
-                                                                        
"l-*-235"
-                                                                        
"l-*-233"
-                                                                        
"l-*-231"
-                                                                        
"l-*-229"
-                                                                        
"l-*-227"
-                                                                        
"l-*-225"
-                                                                        
"l-*-223"
-                                                                        
"l-*-221"
-                                                                        
"l-*-219"
-                                                                        
"l-*-217"
-                                                                        
"l-*-215"
-                                                                        
"l-*-213"
-                                                                        
"l-*-211"
-                                                                        
"l-*-209"))
-                                                                     #(ribcage
-                                                                       
(define-structure
-                                                                         
define-expansion-accessors
-                                                                         
define-expansion-constructors)
-                                                                       ((top)
-                                                                        (top)
-                                                                        (top))
-                                                                       
("l-*-47"
-                                                                        
"l-*-46"
-                                                                        
"l-*-45")))
-                                                                    (hygiene
-                                                                      guile))
-                                                                 (wrap-4290
-                                                                   (cons 
args-19174
-                                                                         (cons 
e1-19175
-                                                                               
e2-19176))
-                                                                   w-18808
-                                                                   
mod-18811))))
-                                                     (begin
-                                                       (if (if s-18809
-                                                             
(supports-source-properties?
-                                                               e-19184)
-                                                             #f)
-                                                         
(set-source-properties!
-                                                           e-19184
-                                                           s-18809))
-                                                       e-19184))
-                                                   '(())
-                                                   s-18809
-                                                   mod-18811))
-                                               tmp-18969)
-                                             (let ((tmp-19191
-                                                     ($sc-dispatch
-                                                       e-18806
-                                                       '(_ any))))
-                                               (if (if tmp-19191
-                                                     (@apply
-                                                       (lambda (name-19195)
-                                                         (if (symbol?
-                                                               name-19195)
-                                                           #t
-                                                           (if (if (vector?
-                                                                     
name-19195)
-                                                                 (if (= 
(vector-length
-                                                                          
name-19195)
-                                                                        4)
-                                                                   (eq? 
(vector-ref
-                                                                          
name-19195
-                                                                          0)
-                                                                        
'syntax-object)
-                                                                   #f)
-                                                                 #f)
-                                                             (symbol?
-                                                               (vector-ref
-                                                                 name-19195
-                                                                 1))
-                                                             #f)))
-                                                       tmp-19191)
-                                                     #f)
-                                                 (@apply
-                                                   (lambda (name-19222)
-                                                     (values
-                                                       'define-form
-                                                       (wrap-4290
-                                                         name-19222
-                                                         w-18808
-                                                         mod-18811)
-                                                       (wrap-4290
-                                                         e-18806
-                                                         w-18808
-                                                         mod-18811)
-                                                       '(#(syntax-object
-                                                           if
-                                                           ((top)
-                                                            #(ribcage
-                                                              #(name)
-                                                              #((top))
-                                                              #("l-*-1915"))
-                                                            #(ribcage () () ())
-                                                            #(ribcage
-                                                              #(key)
-                                                              #((m-*-1867 top))
-                                                              #("l-*-1868"))
-                                                            #(ribcage () () ())
-                                                            #(ribcage () () ())
-                                                            #(ribcage
-                                                              #(ftype
-                                                                fval
-                                                                fform
-                                                                fe
-                                                                fw
-                                                                fs
-                                                                fmod)
-                                                              #((top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top))
-                                                              #("l-*-1860"
-                                                                "l-*-1861"
-                                                                "l-*-1862"
-                                                                "l-*-1863"
-                                                                "l-*-1864"
-                                                                "l-*-1865"
-                                                                "l-*-1866"))
-                                                            #(ribcage () () ())
-                                                            #(ribcage
-                                                              #(first)
-                                                              #((top))
-                                                              #("l-*-1851"))
-                                                            #(ribcage () () ())
-                                                            #(ribcage () () ())
-                                                            #(ribcage
-                                                              #(e
-                                                                r
-                                                                w
-                                                                s
-                                                                rib
-                                                                mod
-                                                                for-car?)
-                                                              #((top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top))
-                                                              #("l-*-1827"
-                                                                "l-*-1828"
-                                                                "l-*-1829"
-                                                                "l-*-1830"
-                                                                "l-*-1831"
-                                                                "l-*-1832"
-                                                                "l-*-1833"))
-                                                            #(ribcage
-                                                              (lambda-var-list
-                                                                gen-var
-                                                                strip
-                                                                
expand-lambda-case
-                                                                lambda*-formals
-                                                                
expand-simple-lambda
-                                                                lambda-formals
-                                                                ellipsis?
-                                                                expand-void
-                                                                
eval-local-transformer
-                                                                
expand-local-syntax
-                                                                expand-body
-                                                                expand-macro
-                                                                
expand-application
-                                                                expand-expr
-                                                                expand
-                                                                syntax-type
-                                                                parse-when-list
-                                                                
expand-install-global
-                                                                
expand-top-sequence
-                                                                expand-sequence
-                                                                source-wrap
-                                                                wrap
-                                                                
bound-id-member?
-                                                                
distinct-bound-ids?
-                                                                
valid-bound-ids?
-                                                                bound-id=?
-                                                                free-id=?
-                                                                
with-transformer-environment
-                                                                
transformer-environment
-                                                                
resolve-identifier
-                                                                
locally-bound-identifiers
-                                                                id-var-name
-                                                                same-marks?
-                                                                join-marks
-                                                                join-wraps
-                                                                smart-append
-                                                                
make-binding-wrap
-                                                                extend-ribcage!
-                                                                
make-empty-ribcage
-                                                                new-mark
-                                                                anti-mark
-                                                                the-anti-mark
-                                                                top-marked?
-                                                                top-wrap
-                                                                empty-wrap
-                                                                
set-ribcage-labels!
-                                                                
set-ribcage-marks!
-                                                                
set-ribcage-symnames!
-                                                                ribcage-labels
-                                                                ribcage-marks
-                                                                
ribcage-symnames
-                                                                ribcage?
-                                                                make-ribcage
-                                                                gen-labels
-                                                                gen-label
-                                                                make-rename
-                                                                rename-marks
-                                                                rename-new
-                                                                rename-old
-                                                                subst-rename?
-                                                                wrap-subst
-                                                                wrap-marks
-                                                                make-wrap
-                                                                
id-sym-name&marks
-                                                                id-sym-name
-                                                                id?
-                                                                nonsymbol-id?
-                                                                global-extend
-                                                                lookup
-                                                                macros-only-env
-                                                                extend-var-env
-                                                                extend-env
-                                                                null-env
-                                                                binding-value
-                                                                binding-type
-                                                                make-binding
-                                                                arg-check
-                                                                
source-annotation
-                                                                no-source
-                                                                
set-syntax-object-module!
-                                                                
set-syntax-object-wrap!
-                                                                
set-syntax-object-expression!
-                                                                
syntax-object-module
-                                                                
syntax-object-wrap
-                                                                
syntax-object-expression
-                                                                syntax-object?
-                                                                
make-syntax-object
-                                                                
build-lexical-var
-                                                                build-letrec
-                                                                build-named-let
-                                                                build-let
-                                                                build-sequence
-                                                                build-data
-                                                                build-primref
-                                                                
build-lambda-case
-                                                                
build-case-lambda
-                                                                
build-simple-lambda
-                                                                
build-global-definition
-                                                                
build-global-assignment
-                                                                
build-global-reference
-                                                                
analyze-variable
-                                                                
build-lexical-assignment
-                                                                
build-lexical-reference
-                                                                build-dynlet
-                                                                
build-conditional
-                                                                
build-application
-                                                                build-void
-                                                                
maybe-name-value!
-                                                                decorate-source
-                                                                
get-global-definition-hook
-                                                                
put-global-definition-hook
-                                                                session-id
-                                                                local-eval-hook
-                                                                
top-level-eval-hook
-                                                                fx<
-                                                                fx=
-                                                                fx-
-                                                                fx+
-                                                                
set-lambda-meta!
-                                                                lambda-meta
-                                                                lambda?
-                                                                make-dynlet
-                                                                make-letrec
-                                                                make-let
-                                                                
make-lambda-case
-                                                                make-lambda
-                                                                make-sequence
-                                                                
make-application
-                                                                
make-conditional
-                                                                
make-toplevel-define
-                                                                
make-toplevel-set
-                                                                
make-toplevel-ref
-                                                                make-module-set
-                                                                make-module-ref
-                                                                
make-lexical-set
-                                                                
make-lexical-ref
-                                                                
make-primitive-ref
-                                                                make-const
-                                                                make-void)
-                                                              ((top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top))
-                                                              ("l-*-476"
-                                                               "l-*-474"
-                                                               "l-*-472"
-                                                               "l-*-470"
-                                                               "l-*-468"
-                                                               "l-*-466"
-                                                               "l-*-464"
-                                                               "l-*-462"
-                                                               "l-*-460"
-                                                               "l-*-458"
-                                                               "l-*-456"
-                                                               "l-*-454"
-                                                               "l-*-452"
-                                                               "l-*-450"
-                                                               "l-*-448"
-                                                               "l-*-446"
-                                                               "l-*-444"
-                                                               "l-*-442"
-                                                               "l-*-440"
-                                                               "l-*-438"
-                                                               "l-*-436"
-                                                               "l-*-434"
-                                                               "l-*-432"
-                                                               "l-*-430"
-                                                               "l-*-428"
-                                                               "l-*-426"
-                                                               "l-*-424"
-                                                               "l-*-422"
-                                                               "l-*-420"
-                                                               "l-*-418"
-                                                               "l-*-416"
-                                                               "l-*-414"
-                                                               "l-*-412"
-                                                               "l-*-410"
-                                                               "l-*-408"
-                                                               "l-*-406"
-                                                               "l-*-404"
-                                                               "l-*-402"
-                                                               "l-*-400"
-                                                               "l-*-399"
-                                                               "l-*-397"
-                                                               "l-*-394"
-                                                               "l-*-393"
-                                                               "l-*-392"
-                                                               "l-*-390"
-                                                               "l-*-389"
-                                                               "l-*-387"
-                                                               "l-*-385"
-                                                               "l-*-383"
-                                                               "l-*-381"
-                                                               "l-*-379"
-                                                               "l-*-377"
-                                                               "l-*-375"
-                                                               "l-*-373"
-                                                               "l-*-370"
-                                                               "l-*-368"
-                                                               "l-*-367"
-                                                               "l-*-365"
-                                                               "l-*-363"
-                                                               "l-*-361"
-                                                               "l-*-359"
-                                                               "l-*-358"
-                                                               "l-*-357"
-                                                               "l-*-356"
-                                                               "l-*-354"
-                                                               "l-*-353"
-                                                               "l-*-350"
-                                                               "l-*-348"
-                                                               "l-*-346"
-                                                               "l-*-344"
-                                                               "l-*-342"
-                                                               "l-*-340"
-                                                               "l-*-338"
-                                                               "l-*-337"
-                                                               "l-*-336"
-                                                               "l-*-334"
-                                                               "l-*-332"
-                                                               "l-*-331"
-                                                               "l-*-328"
-                                                               "l-*-327"
-                                                               "l-*-325"
-                                                               "l-*-323"
-                                                               "l-*-321"
-                                                               "l-*-319"
-                                                               "l-*-317"
-                                                               "l-*-315"
-                                                               "l-*-313"
-                                                               "l-*-311"
-                                                               "l-*-309"
-                                                               "l-*-306"
-                                                               "l-*-304"
-                                                               "l-*-302"
-                                                               "l-*-300"
-                                                               "l-*-298"
-                                                               "l-*-296"
-                                                               "l-*-294"
-                                                               "l-*-292"
-                                                               "l-*-290"
-                                                               "l-*-288"
-                                                               "l-*-286"
-                                                               "l-*-284"
-                                                               "l-*-282"
-                                                               "l-*-280"
-                                                               "l-*-278"
-                                                               "l-*-276"
-                                                               "l-*-274"
-                                                               "l-*-272"
-                                                               "l-*-270"
-                                                               "l-*-268"
-                                                               "l-*-266"
-                                                               "l-*-264"
-                                                               "l-*-262"
-                                                               "l-*-260"
-                                                               "l-*-258"
-                                                               "l-*-256"
-                                                               "l-*-255"
-                                                               "l-*-254"
-                                                               "l-*-253"
-                                                               "l-*-252"
-                                                               "l-*-250"
-                                                               "l-*-248"
-                                                               "l-*-246"
-                                                               "l-*-243"
-                                                               "l-*-241"
-                                                               "l-*-239"
-                                                               "l-*-237"
-                                                               "l-*-235"
-                                                               "l-*-233"
-                                                               "l-*-231"
-                                                               "l-*-229"
-                                                               "l-*-227"
-                                                               "l-*-225"
-                                                               "l-*-223"
-                                                               "l-*-221"
-                                                               "l-*-219"
-                                                               "l-*-217"
-                                                               "l-*-215"
-                                                               "l-*-213"
-                                                               "l-*-211"
-                                                               "l-*-209"))
-                                                            #(ribcage
-                                                              (define-structure
-                                                                
define-expansion-accessors
-                                                                
define-expansion-constructors)
-                                                              ((top)
-                                                               (top)
-                                                               (top))
-                                                              ("l-*-47"
-                                                               "l-*-46"
-                                                               "l-*-45")))
-                                                           (hygiene guile))
-                                                         #(syntax-object
-                                                           #f
-                                                           ((top)
-                                                            #(ribcage
-                                                              #(name)
-                                                              #((top))
-                                                              #("l-*-1915"))
-                                                            #(ribcage () () ())
-                                                            #(ribcage
-                                                              #(key)
-                                                              #((m-*-1867 top))
-                                                              #("l-*-1868"))
-                                                            #(ribcage () () ())
-                                                            #(ribcage () () ())
-                                                            #(ribcage
-                                                              #(ftype
-                                                                fval
-                                                                fform
-                                                                fe
-                                                                fw
-                                                                fs
-                                                                fmod)
-                                                              #((top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top))
-                                                              #("l-*-1860"
-                                                                "l-*-1861"
-                                                                "l-*-1862"
-                                                                "l-*-1863"
-                                                                "l-*-1864"
-                                                                "l-*-1865"
-                                                                "l-*-1866"))
-                                                            #(ribcage () () ())
-                                                            #(ribcage
-                                                              #(first)
-                                                              #((top))
-                                                              #("l-*-1851"))
-                                                            #(ribcage () () ())
-                                                            #(ribcage () () ())
-                                                            #(ribcage
-                                                              #(e
-                                                                r
-                                                                w
-                                                                s
-                                                                rib
-                                                                mod
-                                                                for-car?)
-                                                              #((top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top))
-                                                              #("l-*-1827"
-                                                                "l-*-1828"
-                                                                "l-*-1829"
-                                                                "l-*-1830"
-                                                                "l-*-1831"
-                                                                "l-*-1832"
-                                                                "l-*-1833"))
-                                                            #(ribcage
-                                                              (lambda-var-list
-                                                                gen-var
-                                                                strip
-                                                                
expand-lambda-case
-                                                                lambda*-formals
-                                                                
expand-simple-lambda
-                                                                lambda-formals
-                                                                ellipsis?
-                                                                expand-void
-                                                                
eval-local-transformer
-                                                                
expand-local-syntax
-                                                                expand-body
-                                                                expand-macro
-                                                                
expand-application
-                                                                expand-expr
-                                                                expand
-                                                                syntax-type
-                                                                parse-when-list
-                                                                
expand-install-global
-                                                                
expand-top-sequence
-                                                                expand-sequence
-                                                                source-wrap
-                                                                wrap
-                                                                
bound-id-member?
-                                                                
distinct-bound-ids?
-                                                                
valid-bound-ids?
-                                                                bound-id=?
-                                                                free-id=?
-                                                                
with-transformer-environment
-                                                                
transformer-environment
-                                                                
resolve-identifier
-                                                                
locally-bound-identifiers
-                                                                id-var-name
-                                                                same-marks?
-                                                                join-marks
-                                                                join-wraps
-                                                                smart-append
-                                                                
make-binding-wrap
-                                                                extend-ribcage!
-                                                                
make-empty-ribcage
-                                                                new-mark
-                                                                anti-mark
-                                                                the-anti-mark
-                                                                top-marked?
-                                                                top-wrap
-                                                                empty-wrap
-                                                                
set-ribcage-labels!
-                                                                
set-ribcage-marks!
-                                                                
set-ribcage-symnames!
-                                                                ribcage-labels
-                                                                ribcage-marks
-                                                                
ribcage-symnames
-                                                                ribcage?
-                                                                make-ribcage
-                                                                gen-labels
-                                                                gen-label
-                                                                make-rename
-                                                                rename-marks
-                                                                rename-new
-                                                                rename-old
-                                                                subst-rename?
-                                                                wrap-subst
-                                                                wrap-marks
-                                                                make-wrap
-                                                                
id-sym-name&marks
-                                                                id-sym-name
-                                                                id?
-                                                                nonsymbol-id?
-                                                                global-extend
-                                                                lookup
-                                                                macros-only-env
-                                                                extend-var-env
-                                                                extend-env
-                                                                null-env
-                                                                binding-value
-                                                                binding-type
-                                                                make-binding
-                                                                arg-check
-                                                                
source-annotation
-                                                                no-source
-                                                                
set-syntax-object-module!
-                                                                
set-syntax-object-wrap!
-                                                                
set-syntax-object-expression!
-                                                                
syntax-object-module
-                                                                
syntax-object-wrap
-                                                                
syntax-object-expression
-                                                                syntax-object?
-                                                                
make-syntax-object
-                                                                
build-lexical-var
-                                                                build-letrec
-                                                                build-named-let
-                                                                build-let
-                                                                build-sequence
-                                                                build-data
-                                                                build-primref
-                                                                
build-lambda-case
-                                                                
build-case-lambda
-                                                                
build-simple-lambda
-                                                                
build-global-definition
-                                                                
build-global-assignment
-                                                                
build-global-reference
-                                                                
analyze-variable
-                                                                
build-lexical-assignment
-                                                                
build-lexical-reference
-                                                                build-dynlet
-                                                                
build-conditional
-                                                                
build-application
-                                                                build-void
-                                                                
maybe-name-value!
-                                                                decorate-source
-                                                                
get-global-definition-hook
-                                                                
put-global-definition-hook
-                                                                session-id
-                                                                local-eval-hook
-                                                                
top-level-eval-hook
-                                                                fx<
-                                                                fx=
-                                                                fx-
-                                                                fx+
-                                                                
set-lambda-meta!
-                                                                lambda-meta
-                                                                lambda?
-                                                                make-dynlet
-                                                                make-letrec
-                                                                make-let
-                                                                
make-lambda-case
-                                                                make-lambda
-                                                                make-sequence
-                                                                
make-application
-                                                                
make-conditional
-                                                                
make-toplevel-define
-                                                                
make-toplevel-set
-                                                                
make-toplevel-ref
-                                                                make-module-set
-                                                                make-module-ref
-                                                                
make-lexical-set
-                                                                
make-lexical-ref
-                                                                
make-primitive-ref
-                                                                make-const
-                                                                make-void)
-                                                              ((top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top))
-                                                              ("l-*-476"
-                                                               "l-*-474"
-                                                               "l-*-472"
-                                                               "l-*-470"
-                                                               "l-*-468"
-                                                               "l-*-466"
-                                                               "l-*-464"
-                                                               "l-*-462"
-                                                               "l-*-460"
-                                                               "l-*-458"
-                                                               "l-*-456"
-                                                               "l-*-454"
-                                                               "l-*-452"
-                                                               "l-*-450"
-                                                               "l-*-448"
-                                                               "l-*-446"
-                                                               "l-*-444"
-                                                               "l-*-442"
-                                                               "l-*-440"
-                                                               "l-*-438"
-                                                               "l-*-436"
-                                                               "l-*-434"
-                                                               "l-*-432"
-                                                               "l-*-430"
-                                                               "l-*-428"
-                                                               "l-*-426"
-                                                               "l-*-424"
-                                                               "l-*-422"
-                                                               "l-*-420"
-                                                               "l-*-418"
-                                                               "l-*-416"
-                                                               "l-*-414"
-                                                               "l-*-412"
-                                                               "l-*-410"
-                                                               "l-*-408"
-                                                               "l-*-406"
-                                                               "l-*-404"
-                                                               "l-*-402"
-                                                               "l-*-400"
-                                                               "l-*-399"
-                                                               "l-*-397"
-                                                               "l-*-394"
-                                                               "l-*-393"
-                                                               "l-*-392"
-                                                               "l-*-390"
-                                                               "l-*-389"
-                                                               "l-*-387"
-                                                               "l-*-385"
-                                                               "l-*-383"
-                                                               "l-*-381"
-                                                               "l-*-379"
-                                                               "l-*-377"
-                                                               "l-*-375"
-                                                               "l-*-373"
-                                                               "l-*-370"
-                                                               "l-*-368"
-                                                               "l-*-367"
-                                                               "l-*-365"
-                                                               "l-*-363"
-                                                               "l-*-361"
-                                                               "l-*-359"
-                                                               "l-*-358"
-                                                               "l-*-357"
-                                                               "l-*-356"
-                                                               "l-*-354"
-                                                               "l-*-353"
-                                                               "l-*-350"
-                                                               "l-*-348"
-                                                               "l-*-346"
-                                                               "l-*-344"
-                                                               "l-*-342"
-                                                               "l-*-340"
-                                                               "l-*-338"
-                                                               "l-*-337"
-                                                               "l-*-336"
-                                                               "l-*-334"
-                                                               "l-*-332"
-                                                               "l-*-331"
-                                                               "l-*-328"
-                                                               "l-*-327"
-                                                               "l-*-325"
-                                                               "l-*-323"
-                                                               "l-*-321"
-                                                               "l-*-319"
-                                                               "l-*-317"
-                                                               "l-*-315"
-                                                               "l-*-313"
-                                                               "l-*-311"
-                                                               "l-*-309"
-                                                               "l-*-306"
-                                                               "l-*-304"
-                                                               "l-*-302"
-                                                               "l-*-300"
-                                                               "l-*-298"
-                                                               "l-*-296"
-                                                               "l-*-294"
-                                                               "l-*-292"
-                                                               "l-*-290"
-                                                               "l-*-288"
-                                                               "l-*-286"
-                                                               "l-*-284"
-                                                               "l-*-282"
-                                                               "l-*-280"
-                                                               "l-*-278"
-                                                               "l-*-276"
-                                                               "l-*-274"
-                                                               "l-*-272"
-                                                               "l-*-270"
-                                                               "l-*-268"
-                                                               "l-*-266"
-                                                               "l-*-264"
-                                                               "l-*-262"
-                                                               "l-*-260"
-                                                               "l-*-258"
-                                                               "l-*-256"
-                                                               "l-*-255"
-                                                               "l-*-254"
-                                                               "l-*-253"
-                                                               "l-*-252"
-                                                               "l-*-250"
-                                                               "l-*-248"
-                                                               "l-*-246"
-                                                               "l-*-243"
-                                                               "l-*-241"
-                                                               "l-*-239"
-                                                               "l-*-237"
-                                                               "l-*-235"
-                                                               "l-*-233"
-                                                               "l-*-231"
-                                                               "l-*-229"
-                                                               "l-*-227"
-                                                               "l-*-225"
-                                                               "l-*-223"
-                                                               "l-*-221"
-                                                               "l-*-219"
-                                                               "l-*-217"
-                                                               "l-*-215"
-                                                               "l-*-213"
-                                                               "l-*-211"
-                                                               "l-*-209"))
-                                                            #(ribcage
-                                                              (define-structure
-                                                                
define-expansion-accessors
-                                                                
define-expansion-constructors)
-                                                              ((top)
-                                                               (top)
-                                                               (top))
-                                                              ("l-*-47"
-                                                               "l-*-46"
-                                                               "l-*-45")))
-                                                           (hygiene guile))
-                                                         #(syntax-object
-                                                           #f
-                                                           ((top)
-                                                            #(ribcage
-                                                              #(name)
-                                                              #((top))
-                                                              #("l-*-1915"))
-                                                            #(ribcage () () ())
-                                                            #(ribcage
-                                                              #(key)
-                                                              #((m-*-1867 top))
-                                                              #("l-*-1868"))
-                                                            #(ribcage () () ())
-                                                            #(ribcage () () ())
-                                                            #(ribcage
-                                                              #(ftype
-                                                                fval
-                                                                fform
-                                                                fe
-                                                                fw
-                                                                fs
-                                                                fmod)
-                                                              #((top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top))
-                                                              #("l-*-1860"
-                                                                "l-*-1861"
-                                                                "l-*-1862"
-                                                                "l-*-1863"
-                                                                "l-*-1864"
-                                                                "l-*-1865"
-                                                                "l-*-1866"))
-                                                            #(ribcage () () ())
-                                                            #(ribcage
-                                                              #(first)
-                                                              #((top))
-                                                              #("l-*-1851"))
-                                                            #(ribcage () () ())
-                                                            #(ribcage () () ())
-                                                            #(ribcage
-                                                              #(e
-                                                                r
-                                                                w
-                                                                s
-                                                                rib
-                                                                mod
-                                                                for-car?)
-                                                              #((top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top)
-                                                                (top))
-                                                              #("l-*-1827"
-                                                                "l-*-1828"
-                                                                "l-*-1829"
-                                                                "l-*-1830"
-                                                                "l-*-1831"
-                                                                "l-*-1832"
-                                                                "l-*-1833"))
-                                                            #(ribcage
-                                                              (lambda-var-list
-                                                                gen-var
-                                                                strip
-                                                                
expand-lambda-case
-                                                                lambda*-formals
-                                                                
expand-simple-lambda
-                                                                lambda-formals
-                                                                ellipsis?
-                                                                expand-void
-                                                                
eval-local-transformer
-                                                                
expand-local-syntax
-                                                                expand-body
-                                                                expand-macro
-                                                                
expand-application
-                                                                expand-expr
-                                                                expand
-                                                                syntax-type
-                                                                parse-when-list
-                                                                
expand-install-global
-                                                                
expand-top-sequence
-                                                                expand-sequence
-                                                                source-wrap
-                                                                wrap
-                                                                
bound-id-member?
-                                                                
distinct-bound-ids?
-                                                                
valid-bound-ids?
-                                                                bound-id=?
-                                                                free-id=?
-                                                                
with-transformer-environment
-                                                                
transformer-environment
-                                                                
resolve-identifier
-                                                                
locally-bound-identifiers
-                                                                id-var-name
-                                                                same-marks?
-                                                                join-marks
-                                                                join-wraps
-                                                                smart-append
-                                                                
make-binding-wrap
-                                                                extend-ribcage!
-                                                                
make-empty-ribcage
-                                                                new-mark
-                                                                anti-mark
-                                                                the-anti-mark
-                                                                top-marked?
-                                                                top-wrap
-                                                                empty-wrap
-                                                                
set-ribcage-labels!
-                                                                
set-ribcage-marks!
-                                                                
set-ribcage-symnames!
-                                                                ribcage-labels
-                                                                ribcage-marks
-                                                                
ribcage-symnames
-                                                                ribcage?
-                                                                make-ribcage
-                                                                gen-labels
-                                                                gen-label
-                                                                make-rename
-                                                                rename-marks
-                                                                rename-new
-                                                                rename-old
-                                                                subst-rename?
-                                                                wrap-subst
-                                                                wrap-marks
-                                                                make-wrap
-                                                                
id-sym-name&marks
-                                                                id-sym-name
-                                                                id?
-                                                                nonsymbol-id?
-                                                                global-extend
-                                                                lookup
-                                                                macros-only-env
-                                                                extend-var-env
-                                                                extend-env
-                                                                null-env
-                                                                binding-value
-                                                                binding-type
-                                                                make-binding
-                                                                arg-check
-                                                                
source-annotation
-                                                                no-source
-                                                                
set-syntax-object-module!
-                                                                
set-syntax-object-wrap!
-                                                                
set-syntax-object-expression!
-                                                                
syntax-object-module
-                                                                
syntax-object-wrap
-                                                                
syntax-object-expression
-                                                                syntax-object?
-                                                                
make-syntax-object
-                                                                
build-lexical-var
-                                                                build-letrec
-                                                                build-named-let
-                                                                build-let
-                                                                build-sequence
-                                                                build-data
-                                                                build-primref
-                                                                
build-lambda-case
-                                                                
build-case-lambda
-                                                                
build-simple-lambda
-                                                                
build-global-definition
-                                                                
build-global-assignment
-                                                                
build-global-reference
-                                                                
analyze-variable
-                                                                
build-lexical-assignment
-                                                                
build-lexical-reference
-                                                                build-dynlet
-                                                                
build-conditional
-                                                                
build-application
-                                                                build-void
-                                                                
maybe-name-value!
-                                                                decorate-source
-                                                                
get-global-definition-hook
-                                                                
put-global-definition-hook
-                                                                session-id
-                                                                local-eval-hook
-                                                                
top-level-eval-hook
-                                                                fx<
-                                                                fx=
-                                                                fx-
-                                                                fx+
-                                                                
set-lambda-meta!
-                                                                lambda-meta
-                                                                lambda?
-                                                                make-dynlet
-                                                                make-letrec
-                                                                make-let
-                                                                
make-lambda-case
-                                                                make-lambda
-                                                                make-sequence
-                                                                
make-application
-                                                                
make-conditional
-                                                                
make-toplevel-define
-                                                                
make-toplevel-set
-                                                                
make-toplevel-ref
-                                                                make-module-set
-                                                                make-module-ref
-                                                                
make-lexical-set
-                                                                
make-lexical-ref
-                                                                
make-primitive-ref
-                                                                make-const
-                                                                make-void)
-                                                              ((top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top)
-                                                               (top))
-                                                              ("l-*-476"
-                                                               "l-*-474"
-                                                               "l-*-472"
-                                                               "l-*-470"
-                                                               "l-*-468"
-                                                               "l-*-466"
-                                                               "l-*-464"
-                                                               "l-*-462"
-                                                               "l-*-460"
-                                                               "l-*-458"
-                                                               "l-*-456"
-                                                               "l-*-454"
-                                                               "l-*-452"
-                                                               "l-*-450"
-                                                               "l-*-448"
-                                                               "l-*-446"
-                                                               "l-*-444"
-                                                               "l-*-442"
-                                                               "l-*-440"
-                                                               "l-*-438"
-                                                               "l-*-436"
-                                                               "l-*-434"
-                                                               "l-*-432"
-                                                               "l-*-430"
-                                                               "l-*-428"
-                                                               "l-*-426"
-                                                               "l-*-424"
-                                                               "l-*-422"
-                                                               "l-*-420"
-                                                               "l-*-418"
-                                                               "l-*-416"
-                                                               "l-*-414"
-                                                               "l-*-412"
-                                                               "l-*-410"
-                                                               "l-*-408"
-                                                               "l-*-406"
-                                                               "l-*-404"
-                                                               "l-*-402"
-                                                               "l-*-400"
-                                                               "l-*-399"
-                                                               "l-*-397"
-                                                               "l-*-394"
-                                                               "l-*-393"
-                                                               "l-*-392"
-                                                               "l-*-390"
-                                                               "l-*-389"
-                                                               "l-*-387"
-                                                               "l-*-385"
-                                                               "l-*-383"
-                                                               "l-*-381"
-                                                               "l-*-379"
-                                                               "l-*-377"
-                                                               "l-*-375"
-                                                               "l-*-373"
-                                                               "l-*-370"
-                                                               "l-*-368"
-                                                               "l-*-367"
-                                                               "l-*-365"
-                                                               "l-*-363"
-                                                               "l-*-361"
-                                                               "l-*-359"
-                                                               "l-*-358"
-                                                               "l-*-357"
-                                                               "l-*-356"
-                                                               "l-*-354"
-                                                               "l-*-353"
-                                                               "l-*-350"
-                                                               "l-*-348"
-                                                               "l-*-346"
-                                                               "l-*-344"
-                                                               "l-*-342"
-                                                               "l-*-340"
-                                                               "l-*-338"
-                                                               "l-*-337"
-                                                               "l-*-336"
-                                                               "l-*-334"
-                                                               "l-*-332"
-                                                               "l-*-331"
-                                                               "l-*-328"
-                                                               "l-*-327"
-                                                               "l-*-325"
-                                                               "l-*-323"
-                                                               "l-*-321"
-                                                               "l-*-319"
-                                                               "l-*-317"
-                                                               "l-*-315"
-                                                               "l-*-313"
-                                                               "l-*-311"
-                                                               "l-*-309"
-                                                               "l-*-306"
-                                                               "l-*-304"
-                                                               "l-*-302"
-                                                               "l-*-300"
-                                                               "l-*-298"
-                                                               "l-*-296"
-                                                               "l-*-294"
-                                                               "l-*-292"
-                                                               "l-*-290"
-                                                               "l-*-288"
-                                                               "l-*-286"
-                                                               "l-*-284"
-                                                               "l-*-282"
-                                                               "l-*-280"
-                                                               "l-*-278"
-                                                               "l-*-276"
-                                                               "l-*-274"
-                                                               "l-*-272"
-                                                               "l-*-270"
-                                                               "l-*-268"
-                                                               "l-*-266"
-                                                               "l-*-264"
-                                                               "l-*-262"
-                                                               "l-*-260"
-                                                               "l-*-258"
-                                                               "l-*-256"
-                                                               "l-*-255"
-                                                               "l-*-254"
-                                                               "l-*-253"
-                                                               "l-*-252"
-                                                               "l-*-250"
-                                                               "l-*-248"
-                                                               "l-*-246"
-                                                               "l-*-243"
-                                                               "l-*-241"
-                                                               "l-*-239"
-                                                               "l-*-237"
-                                                               "l-*-235"
-                                                               "l-*-233"
-                                                               "l-*-231"
-                                                               "l-*-229"
-                                                               "l-*-227"
-                                                               "l-*-225"
-                                                               "l-*-223"
-                                                               "l-*-221"
-                                                               "l-*-219"
-                                                               "l-*-217"
-                                                               "l-*-215"
-                                                               "l-*-213"
-                                                               "l-*-211"
-                                                               "l-*-209"))
-                                                            #(ribcage
-                                                              (define-structure
-                                                                
define-expansion-accessors
-                                                                
define-expansion-constructors)
-                                                              ((top)
-                                                               (top)
-                                                               (top))
-                                                              ("l-*-47"
-                                                               "l-*-46"
-                                                               "l-*-45")))
-                                                           (hygiene guile)))
-                                                       '(())
-                                                       s-18809
-                                                       mod-18811))
-                                                   tmp-19191)
-                                                 (syntax-violation
-                                                   #f
-                                                   "source expression failed 
to match any pattern"
-                                                   e-18806)))))))
-                                     (if (eqv? ftype-18859 'define-syntax)
-                                       (let ((tmp-19246
-                                               ($sc-dispatch
-                                                 e-18806
-                                                 '(_ any any))))
-                                         (if (if tmp-19246
-                                               (@apply
-                                                 (lambda (name-19250 val-19251)
-                                                   (if (symbol? name-19250)
-                                                     #t
-                                                     (if (if (vector?
-                                                               name-19250)
-                                                           (if (= 
(vector-length
-                                                                    name-19250)
-                                                                  4)
-                                                             (eq? (vector-ref
-                                                                    name-19250
-                                                                    0)
-                                                                  
'syntax-object)
-                                                             #f)
-                                                           #f)
-                                                       (symbol?
-                                                         (vector-ref
-                                                           name-19250
-                                                           1))
-                                                       #f)))
-                                                 tmp-19246)
-                                               #f)
-                                           (@apply
-                                             (lambda (name-19278 val-19279)
-                                               (values
-                                                 'define-syntax-form
-                                                 name-19278
-                                                 e-18806
-                                                 val-19279
-                                                 w-18808
-                                                 s-18809
-                                                 mod-18811))
-                                             tmp-19246)
-                                           (syntax-violation
-                                             #f
-                                             "source expression failed to 
match any pattern"
-                                             e-18806)))
-                                       (if (eqv? ftype-18859
-                                                 'define-syntax-parameter)
-                                         (let ((tmp-19293
-                                                 ($sc-dispatch
-                                                   e-18806
-                                                   '(_ any any))))
-                                           (if (if tmp-19293
-                                                 (@apply
-                                                   (lambda (name-19297
-                                                            val-19298)
-                                                     (if (symbol? name-19297)
-                                                       #t
-                                                       (if (if (vector?
-                                                                 name-19297)
-                                                             (if (= 
(vector-length
-                                                                      
name-19297)
-                                                                    4)
-                                                               (eq? (vector-ref
-                                                                      
name-19297
-                                                                      0)
-                                                                    
'syntax-object)
-                                                               #f)
-                                                             #f)
-                                                         (symbol?
-                                                           (vector-ref
-                                                             name-19297
-                                                             1))
-                                                         #f)))
-                                                   tmp-19293)
-                                                 #f)
-                                             (@apply
-                                               (lambda (name-19325 val-19326)
-                                                 (values
-                                                   
'define-syntax-parameter-form
-                                                   name-19325
-                                                   e-18806
-                                                   val-19326
-                                                   w-18808
-                                                   s-18809
-                                                   mod-18811))
-                                               tmp-19293)
+           (for-each maybe-name-value! ids val-exps)
+           (make-letrec src in-order? ids vars val-exps body-exp)))))
+   (make-syntax-object
+     (lambda (expression wrap module)
+       (vector 'syntax-object expression wrap module)))
+   (syntax-object?
+     (lambda (x)
+       (and (vector? x)
+            (= (vector-length x) 4)
+            (eq? (vector-ref x 0) 'syntax-object))))
+   (syntax-object-expression (lambda (x) (vector-ref x 1)))
+   (syntax-object-wrap (lambda (x) (vector-ref x 2)))
+   (syntax-object-module (lambda (x) (vector-ref x 3)))
+   (set-syntax-object-expression!
+     (lambda (x update) (vector-set! x 1 update)))
+   (set-syntax-object-wrap!
+     (lambda (x update) (vector-set! x 2 update)))
+   (set-syntax-object-module!
+     (lambda (x update) (vector-set! x 3 update)))
+   (source-annotation
+     (lambda (x)
+       (let ((props (source-properties
+                      (if (syntax-object? x) (syntax-object-expression x) x))))
+         (and (pair? props) props))))
+   (extend-env
+     (lambda (labels bindings r)
+       (if (null? labels)
+         r
+         (extend-env
+           (cdr labels)
+           (cdr bindings)
+           (cons (cons (car labels) (car bindings)) r)))))
+   (extend-var-env
+     (lambda (labels vars r)
+       (if (null? labels)
+         r
+         (extend-var-env
+           (cdr labels)
+           (cdr vars)
+           (cons (cons (car labels) (cons 'lexical (car vars))) r)))))
+   (macros-only-env
+     (lambda (r)
+       (if (null? r)
+         '()
+         (let ((a (car r)))
+           (if (eq? (cadr a) 'macro)
+             (cons a (macros-only-env (cdr r)))
+             (macros-only-env (cdr r)))))))
+   (lookup
+     (lambda (x r mod)
+       (let ((t (assq x r)))
+         (cond (t (cdr t))
+               ((symbol? x) (or (get-global-definition-hook x mod) '(global)))
+               (else '(displaced-lexical))))))
+   (global-extend
+     (lambda (type sym val) (put-global-definition-hook sym type val)))
+   (nonsymbol-id?
+     (lambda (x)
+       (and (syntax-object? x) (symbol? (syntax-object-expression x)))))
+   (id? (lambda (x)
+          (if (symbol? x)
+            #t
+            (and (syntax-object? x) (symbol? (syntax-object-expression x))))))
+   (id-sym-name&marks
+     (lambda (x w)
+       (if (syntax-object? x)
+         (values
+           (syntax-object-expression x)
+           (join-marks (car w) (car (syntax-object-wrap x))))
+         (values x (car w)))))
+   (gen-label
+     (lambda ()
+       (string-append "l-" (session-id) (symbol->string (gensym "-")))))
+   (gen-labels
+     (lambda (ls)
+       (if (null? ls) '() (cons (gen-label) (gen-labels (cdr ls))))))
+   (make-ribcage
+     (lambda (symnames marks labels)
+       (vector 'ribcage symnames marks labels)))
+   (ribcage?
+     (lambda (x)
+       (and (vector? x)
+            (= (vector-length x) 4)
+            (eq? (vector-ref x 0) 'ribcage))))
+   (ribcage-symnames (lambda (x) (vector-ref x 1)))
+   (ribcage-marks (lambda (x) (vector-ref x 2)))
+   (ribcage-labels (lambda (x) (vector-ref x 3)))
+   (set-ribcage-symnames! (lambda (x update) (vector-set! x 1 update)))
+   (set-ribcage-marks! (lambda (x update) (vector-set! x 2 update)))
+   (set-ribcage-labels! (lambda (x update) (vector-set! x 3 update)))
+   (anti-mark
+     (lambda (w) (cons (cons #f (car w)) (cons 'shift (cdr w)))))
+   (extend-ribcage!
+     (lambda (ribcage id label)
+       (set-ribcage-symnames!
+         ribcage
+         (cons (syntax-object-expression id) (ribcage-symnames ribcage)))
+       (set-ribcage-marks!
+         ribcage
+         (cons (car (syntax-object-wrap id)) (ribcage-marks ribcage)))
+       (set-ribcage-labels! ribcage (cons label (ribcage-labels ribcage)))))
+   (make-binding-wrap
+     (lambda (ids labels w)
+       (if (null? ids)
+         w
+         (cons (car w)
+               (cons (let* ((labelvec (list->vector labels)) (n (vector-length 
labelvec)))
+                       (let ((symnamevec (make-vector n)) (marksvec 
(make-vector n)))
+                         (let f ((ids ids) (i 0))
+                           (if (not (null? ids))
+                             (call-with-values
+                               (lambda () (id-sym-name&marks (car ids) w))
+                               (lambda (symname marks)
+                                 (vector-set! symnamevec i symname)
+                                 (vector-set! marksvec i marks)
+                                 (f (cdr ids) (+ i 1))))))
+                         (make-ribcage symnamevec marksvec labelvec)))
+                     (cdr w))))))
+   (smart-append (lambda (m1 m2) (if (null? m2) m1 (append m1 m2))))
+   (join-wraps
+     (lambda (w1 w2)
+       (let ((m1 (car w1)) (s1 (cdr w1)))
+         (if (null? m1)
+           (if (null? s1) w2 (cons (car w2) (smart-append s1 (cdr w2))))
+           (cons (smart-append m1 (car w2)) (smart-append s1 (cdr w2)))))))
+   (join-marks (lambda (m1 m2) (smart-append m1 m2)))
+   (same-marks?
+     (lambda (x y)
+       (or (eq? x y)
+           (and (not (null? x))
+                (not (null? y))
+                (eq? (car x) (car y))
+                (same-marks? (cdr x) (cdr y))))))
+   (id-var-name
+     (lambda (id w)
+       (letrec*
+         ((search
+            (lambda (sym subst marks)
+              (if (null? subst)
+                (values #f marks)
+                (let ((fst (car subst)))
+                  (if (eq? fst 'shift)
+                    (search sym (cdr subst) (cdr marks))
+                    (let ((symnames (ribcage-symnames fst)))
+                      (if (vector? symnames)
+                        (search-vector-rib sym subst marks symnames fst)
+                        (search-list-rib sym subst marks symnames fst))))))))
+          (search-list-rib
+            (lambda (sym subst marks symnames ribcage)
+              (let f ((symnames symnames) (i 0))
+                (cond ((null? symnames) (search sym (cdr subst) marks))
+                      ((and (eq? (car symnames) sym)
+                            (same-marks? marks (list-ref (ribcage-marks 
ribcage) i)))
+                       (values (list-ref (ribcage-labels ribcage) i) marks))
+                      (else (f (cdr symnames) (+ i 1)))))))
+          (search-vector-rib
+            (lambda (sym subst marks symnames ribcage)
+              (let ((n (vector-length symnames)))
+                (let f ((i 0))
+                  (cond ((= i n) (search sym (cdr subst) marks))
+                        ((and (eq? (vector-ref symnames i) sym)
+                              (same-marks? marks (vector-ref (ribcage-marks 
ribcage) i)))
+                         (values (vector-ref (ribcage-labels ribcage) i) 
marks))
+                        (else (f (+ i 1)))))))))
+         (cond ((symbol? id) (or (search id (cdr w) (car w)) id))
+               ((syntax-object? id)
+                (let ((id (syntax-object-expression id)) (w1 
(syntax-object-wrap id)))
+                  (let ((marks (join-marks (car w) (car w1))))
+                    (call-with-values
+                      (lambda () (search id (cdr w) marks))
+                      (lambda (new-id marks) (or new-id (search id (cdr w1) 
marks) id))))))
+               (else (syntax-violation 'id-var-name "invalid id" id))))))
+   (locally-bound-identifiers
+     (lambda (w mod)
+       (letrec*
+         ((scan (lambda (subst results)
+                  (if (null? subst)
+                    results
+                    (let ((fst (car subst)))
+                      (if (eq? fst 'shift)
+                        (scan (cdr subst) results)
+                        (let ((symnames (ribcage-symnames fst)) (marks 
(ribcage-marks fst)))
+                          (if (vector? symnames)
+                            (scan-vector-rib subst symnames marks results)
+                            (scan-list-rib subst symnames marks results))))))))
+          (scan-list-rib
+            (lambda (subst symnames marks results)
+              (let f ((symnames symnames) (marks marks) (results results))
+                (if (null? symnames)
+                  (scan (cdr subst) results)
+                  (f (cdr symnames)
+                     (cdr marks)
+                     (cons (wrap (car symnames) (anti-mark (cons (car marks) 
subst)) mod)
+                           results))))))
+          (scan-vector-rib
+            (lambda (subst symnames marks results)
+              (let ((n (vector-length symnames)))
+                (let f ((i 0) (results results))
+                  (if (= i n)
+                    (scan (cdr subst) results)
+                    (f (+ i 1)
+                       (cons (wrap (vector-ref symnames i)
+                                   (anti-mark (cons (vector-ref marks i) 
subst))
+                                   mod)
+                             results))))))))
+         (scan (cdr w) '()))))
+   (resolve-identifier
+     (lambda (id w r mod)
+       (letrec*
+         ((resolve-global
+            (lambda (var mod)
+              (let ((b (or (get-global-definition-hook var mod) '(global))))
+                (if (eq? (car b) 'global)
+                  (values 'global var mod)
+                  (values (car b) (cdr b) mod)))))
+          (resolve-lexical
+            (lambda (label mod)
+              (let ((b (or (assq-ref r label) '(displaced-lexical))))
+                (values (car b) (cdr b) mod)))))
+         (let ((n (id-var-name id w)))
+           (cond ((symbol? n)
+                  (resolve-global
+                    n
+                    (if (syntax-object? id) (syntax-object-module id) mod)))
+                 ((string? n)
+                  (resolve-lexical
+                    n
+                    (if (syntax-object? id) (syntax-object-module id) mod)))
+                 (else (error "unexpected id-var-name" id w n)))))))
+   (transformer-environment
+     (make-fluid
+       (lambda (k)
+         (error "called outside the dynamic extent of a syntax transformer"))))
+   (with-transformer-environment
+     (lambda (k) ((fluid-ref transformer-environment) k)))
+   (free-id=?
+     (lambda (i j)
+       (and (eq? (let ((x i)) (if (syntax-object? x) (syntax-object-expression 
x) x))
+                 (let ((x j)) (if (syntax-object? x) (syntax-object-expression 
x) x)))
+            (eq? (id-var-name i '(())) (id-var-name j '(()))))))
+   (bound-id=?
+     (lambda (i j)
+       (if (and (syntax-object? i) (syntax-object? j))
+         (and (eq? (syntax-object-expression i) (syntax-object-expression j))
+              (same-marks?
+                (car (syntax-object-wrap i))
+                (car (syntax-object-wrap j))))
+         (eq? i j))))
+   (valid-bound-ids?
+     (lambda (ids)
+       (and (let all-ids? ((ids ids))
+              (or (null? ids) (and (id? (car ids)) (all-ids? (cdr ids)))))
+            (distinct-bound-ids? ids))))
+   (distinct-bound-ids?
+     (lambda (ids)
+       (let distinct? ((ids ids))
+         (or (null? ids)
+             (and (not (bound-id-member? (car ids) (cdr ids)))
+                  (distinct? (cdr ids)))))))
+   (bound-id-member?
+     (lambda (x list)
+       (and (not (null? list))
+            (or (bound-id=? x (car list)) (bound-id-member? x (cdr list))))))
+   (wrap (lambda (x w defmod)
+           (cond ((and (null? (car w)) (null? (cdr w))) x)
+                 ((syntax-object? x)
+                  (make-syntax-object
+                    (syntax-object-expression x)
+                    (join-wraps w (syntax-object-wrap x))
+                    (syntax-object-module x)))
+                 ((null? x) x)
+                 (else (make-syntax-object x w defmod)))))
+   (source-wrap
+     (lambda (x w s defmod) (wrap (decorate-source x s) w defmod)))
+   (expand-sequence
+     (lambda (body r w s mod)
+       (build-sequence
+         s
+         (let dobody ((body body) (r r) (w w) (mod mod))
+           (if (null? body)
+             '()
+             (let ((first (expand (car body) r w mod)))
+               (cons first (dobody (cdr body) r w mod))))))))
+   (expand-top-sequence
+     (lambda (body r w s m esew mod)
+       (letrec*
+         ((scan (lambda (body r w s m esew mod exps)
+                  (if (null? body)
+                    exps
+                    (call-with-values
+                      (lambda ()
+                        (call-with-values
+                          (lambda ()
+                            (let ((e (car body)))
+                              (syntax-type e r w (or (source-annotation e) s) 
#f mod #f)))
+                          (lambda (type value form e w s mod)
+                            (let ((key type))
+                              (cond ((memv key '(begin-form))
+                                     (let* ((tmp e) (tmp-1 ($sc-dispatch tmp 
'(_))))
+                                       (if tmp-1
+                                         (apply (lambda () exps) tmp-1)
+                                         (let ((tmp-1 ($sc-dispatch tmp '(_ 
any . each-any))))
+                                           (if tmp-1
+                                             (apply (lambda (e1 e2) (scan 
(cons e1 e2) r w s m esew mod exps))
+                                                    tmp-1)
                                              (syntax-violation
                                                #f
                                                "source expression failed to 
match any pattern"
-                                               e-18806)))
-                                         (values
-                                           'call
+                                               tmp))))))
+                                    ((memv key '(local-syntax-form))
+                                     (expand-local-syntax
+                                       value
+                                       e
+                                       r
+                                       w
+                                       s
+                                       mod
+                                       (lambda (body r w s mod) (scan body r w 
s m esew mod exps))))
+                                    ((memv key '(eval-when-form))
+                                     (let* ((tmp-1 e) (tmp ($sc-dispatch tmp-1 
'(_ each-any any . each-any))))
+                                       (if tmp
+                                         (apply (lambda (x e1 e2)
+                                                  (let ((when-list 
(parse-when-list e x)) (body (cons e1 e2)))
+                                                    (cond ((eq? m 'e)
+                                                           (if (memq 'eval 
when-list)
+                                                             (scan body
+                                                                   r
+                                                                   w
+                                                                   s
+                                                                   (if (memq 
'expand when-list) 'c&e 'e)
+                                                                   '(eval)
+                                                                   mod
+                                                                   exps)
+                                                             (begin
+                                                               (if (memq 
'expand when-list)
+                                                                 
(top-level-eval-hook
+                                                                   
(expand-top-sequence body r w s 'e '(eval) mod)
+                                                                   mod))
+                                                               (values exps))))
+                                                          ((memq 'load 
when-list)
+                                                           (cond ((or (memq 
'compile when-list)
+                                                                      (memq 
'expand when-list)
+                                                                      (and 
(eq? m 'c&e) (memq 'eval when-list)))
+                                                                  (scan body r 
w s 'c&e '(compile load) mod exps))
+                                                                 ((memq m '(c 
c&e))
+                                                                  (scan body r 
w s 'c '(load) mod exps))
+                                                                 (else (values 
exps))))
+                                                          ((or (memq 'compile 
when-list)
+                                                               (memq 'expand 
when-list)
+                                                               (and (eq? m 
'c&e) (memq 'eval when-list)))
+                                                           (top-level-eval-hook
+                                                             
(expand-top-sequence body r w s 'e '(eval) mod)
+                                                             mod)
+                                                           (values exps))
+                                                          (else (values 
exps)))))
+                                                tmp)
+                                         (syntax-violation
                                            #f
-                                           e-18806
-                                           e-18806
-                                           w-18808
-                                           s-18809
-                                           mod-18811)))))))))))))))
-             (if (if (vector? e-18806)
-                   (if (= (vector-length e-18806) 4)
-                     (eq? (vector-ref e-18806 0) 'syntax-object)
-                     #f)
-                   #f)
-               (syntax-type-4296
-                 (vector-ref e-18806 1)
-                 r-18807
-                 (join-wraps-4277 w-18808 (vector-ref e-18806 2))
-                 (let ((t-19353
-                         (let ((props-19385
-                                 (source-properties
-                                   (if (if (vector? e-18806)
-                                         (if (= (vector-length e-18806) 4)
-                                           (eq? (vector-ref e-18806 0)
-                                                'syntax-object)
-                                           #f)
-                                         #f)
-                                     (vector-ref e-18806 1)
-                                     e-18806))))
-                           (if (pair? props-19385) props-19385 #f))))
-                   (if t-19353 t-19353 s-18809))
-                 rib-18810
-                 (let ((t-19408 (vector-ref e-18806 3)))
-                   (if t-19408 t-19408 mod-18811))
-                 for-car?-18812)
-               (if (self-evaluating? e-18806)
-                 (values
-                   'constant
-                   #f
-                   e-18806
-                   e-18806
-                   w-18808
-                   s-18809
-                   mod-18811)
-                 (values
-                   'other
-                   #f
-                   e-18806
-                   e-18806
-                   w-18808
-                   s-18809
-                   mod-18811)))))))
-     (expand-4297
-       (lambda (e-19417 r-19418 w-19419 mod-19420)
+                                           "source expression failed to match 
any pattern"
+                                           tmp-1))))
+                                    ((memv key '(define-syntax-form 
define-syntax-parameter-form))
+                                     (let ((n (id-var-name value w)) (r 
(macros-only-env r)))
+                                       (let ((key m))
+                                         (cond ((memv key '(c))
+                                                (cond ((memq 'compile esew)
+                                                       (let ((e 
(expand-install-global n (expand e r w mod))))
+                                                         (top-level-eval-hook 
e mod)
+                                                         (if (memq 'load esew) 
(values (cons e exps)) (values exps))))
+                                                      ((memq 'load esew)
+                                                       (values
+                                                         (cons 
(expand-install-global n (expand e r w mod)) exps)))
+                                                      (else (values exps))))
+                                               ((memv key '(c&e))
+                                                (let ((e 
(expand-install-global n (expand e r w mod))))
+                                                  (top-level-eval-hook e mod)
+                                                  (values (cons e exps))))
+                                               (else
+                                                (if (memq 'eval esew)
+                                                  (top-level-eval-hook
+                                                    (expand-install-global n 
(expand e r w mod))
+                                                    mod))
+                                                (values exps))))))
+                                    ((memv key '(define-form))
+                                     (let* ((n (id-var-name value w)) (type 
(car (lookup n r mod))) (key type))
+                                       (cond ((memv key '(global core macro 
module-ref))
+                                              (if (and (memq m '(c c&e))
+                                                       (not 
(module-local-variable (current-module) n))
+                                                       (current-module))
+                                                (let ((old (module-variable 
(current-module) n)))
+                                                  (if (and (variable? old) 
(variable-bound? old))
+                                                    (module-define! 
(current-module) n (variable-ref old))
+                                                    (module-add! 
(current-module) n (make-undefined-variable)))))
+                                              (values
+                                                (cons (if (eq? m 'c&e)
+                                                        (let ((x 
(build-global-definition s n (expand e r w mod))))
+                                                          (top-level-eval-hook 
x mod)
+                                                          x)
+                                                        (lambda () 
(build-global-definition s n (expand e r w mod))))
+                                                      exps)))
+                                             ((memv key '(displaced-lexical))
+                                              (syntax-violation
+                                                #f
+                                                "identifier out of context"
+                                                (source-wrap form w s mod)
+                                                (wrap value w mod)))
+                                             (else
+                                              (syntax-violation
+                                                #f
+                                                "cannot define keyword at top 
level"
+                                                (source-wrap form w s mod)
+                                                (wrap value w mod))))))
+                                    (else
+                                     (values
+                                       (cons (if (eq? m 'c&e)
+                                               (let ((x (expand-expr type 
value form e r w s mod)))
+                                                 (top-level-eval-hook x mod)
+                                                 x)
+                                               (lambda () (expand-expr type 
value form e r w s mod)))
+                                             exps))))))))
+                      (lambda (exps) (scan (cdr body) r w s m esew mod 
exps)))))))
          (call-with-values
-           (lambda ()
-             (syntax-type-4296
-               e-19417
-               r-19418
-               w-19419
-               (let ((props-19427
-                       (source-properties
-                         (if (if (vector? e-19417)
-                               (if (= (vector-length e-19417) 4)
-                                 (eq? (vector-ref e-19417 0) 'syntax-object)
-                                 #f)
-                               #f)
-                           (vector-ref e-19417 1)
-                           e-19417))))
-                 (if (pair? props-19427) props-19427 #f))
-               #f
-               mod-19420
-               #f))
-           (lambda (type-19450
-                    value-19451
-                    form-19452
-                    e-19453
-                    w-19454
-                    s-19455
-                    mod-19456)
-             (expand-expr-4298
-               type-19450
-               value-19451
-               form-19452
-               e-19453
-               r-19418
-               w-19454
-               s-19455
-               mod-19456)))))
-     (expand-expr-4298
-       (lambda (type-19459
-                value-19460
-                form-19461
-                e-19462
-                r-19463
-                w-19464
-                s-19465
-                mod-19466)
-         (if (eqv? type-19459 'lexical)
-           (make-struct/no-tail
-             (vector-ref %expanded-vtables 3)
-             s-19465
-             e-19462
-             value-19460)
-           (if (if (eqv? type-19459 'core)
-                 #t
-                 (eqv? type-19459 'core-form))
-             (value-19460
-               e-19462
-               r-19463
-               w-19464
-               s-19465
-               mod-19466)
-             (if (eqv? type-19459 'module-ref)
-               (call-with-values
-                 (lambda () (value-19460 e-19462 r-19463 w-19464))
-                 (lambda (e-19502 r-19503 w-19504 s-19505 mod-19506)
-                   (call-with-values
-                     (lambda ()
-                       (syntax-type-4296
-                         e-19502
-                         r-19503
-                         w-19504
-                         (let ((props-19522
-                                 (source-properties
-                                   (if (if (vector? e-19502)
-                                         (if (= (vector-length e-19502) 4)
-                                           (eq? (vector-ref e-19502 0)
-                                                'syntax-object)
-                                           #f)
-                                         #f)
-                                     (vector-ref e-19502 1)
-                                     e-19502))))
-                           (if (pair? props-19522) props-19522 #f))
-                         #f
-                         mod-19506
-                         #f))
-                     (lambda (type-19555
-                              value-19556
-                              form-19557
-                              e-19558
-                              w-19559
-                              s-19560
-                              mod-19561)
-                       (expand-expr-4298
-                         type-19555
-                         value-19556
-                         form-19557
-                         e-19558
-                         r-19503
-                         w-19559
-                         s-19560
-                         mod-19561)))))
-               (if (eqv? type-19459 'lexical-call)
-                 (expand-application-4299
-                   (let ((id-19572 (car e-19462)))
-                     (let ((source-19577
-                             (let ((props-19587
-                                     (source-properties
-                                       (if (if (vector? id-19572)
-                                             (if (= (vector-length id-19572) 4)
-                                               (eq? (vector-ref id-19572 0)
-                                                    'syntax-object)
-                                               #f)
-                                             #f)
-                                         (vector-ref id-19572 1)
-                                         id-19572))))
-                               (if (pair? props-19587) props-19587 #f)))
-                           (name-19578
-                             (if (if (vector? id-19572)
-                                   (if (= (vector-length id-19572) 4)
-                                     (eq? (vector-ref id-19572 0)
-                                          'syntax-object)
-                                     #f)
-                                   #f)
-                               (syntax->datum id-19572)
-                               id-19572)))
-                       (make-struct/no-tail
-                         (vector-ref %expanded-vtables 3)
-                         source-19577
-                         name-19578
-                         value-19460)))
-                   e-19462
-                   r-19463
-                   w-19464
-                   s-19465
-                   mod-19466)
-                 (if (eqv? type-19459 'global-call)
-                   (expand-application-4299
-                     (let ((source-19630
-                             (let ((x-19669 (car e-19462)))
-                               (let ((props-19670
-                                       (source-properties
-                                         (if (if (vector? x-19669)
-                                               (if (= (vector-length x-19669)
-                                                      4)
-                                                 (eq? (vector-ref x-19669 0)
-                                                      'syntax-object)
-                                                 #f)
-                                               #f)
-                                           (vector-ref x-19669 1)
-                                           x-19669))))
-                                 (if (pair? props-19670) props-19670 #f))))
-                           (var-19631
-                             (if (if (vector? value-19460)
-                                   (if (= (vector-length value-19460) 4)
-                                     (eq? (vector-ref value-19460 0)
-                                          'syntax-object)
-                                     #f)
-                                   #f)
-                               (vector-ref value-19460 1)
-                               value-19460))
-                           (mod-19632
-                             (if (if (vector? value-19460)
-                                   (if (= (vector-length value-19460) 4)
-                                     (eq? (vector-ref value-19460 0)
-                                          'syntax-object)
-                                     #f)
-                                   #f)
-                               (vector-ref value-19460 3)
-                               mod-19466)))
-                       (analyze-variable-4233
-                         mod-19632
-                         var-19631
-                         (lambda (mod-19658 var-19659 public?-19660)
-                           (make-struct/no-tail
-                             (vector-ref %expanded-vtables 5)
-                             source-19630
-                             mod-19658
-                             var-19659
-                             public?-19660))
-                         (lambda (var-19683)
-                           (make-struct/no-tail
-                             (vector-ref %expanded-vtables 7)
-                             source-19630
-                             var-19683))))
-                     e-19462
-                     r-19463
-                     w-19464
-                     s-19465
-                     mod-19466)
-                   (if (eqv? type-19459 'constant)
-                     (let ((exp-19698
-                             (strip-4310
-                               (wrap-4290
-                                 (begin
-                                   (if (if s-19465
-                                         (supports-source-properties? e-19462)
-                                         #f)
-                                     (set-source-properties! e-19462 s-19465))
-                                   e-19462)
-                                 w-19464
-                                 mod-19466)
-                               '(()))))
-                       (make-struct/no-tail
-                         (vector-ref %expanded-vtables 1)
-                         s-19465
-                         exp-19698))
-                     (if (eqv? type-19459 'global)
-                       (analyze-variable-4233
-                         mod-19466
-                         value-19460
-                         (lambda (mod-19737 var-19738 public?-19739)
-                           (make-struct/no-tail
-                             (vector-ref %expanded-vtables 5)
-                             s-19465
-                             mod-19737
-                             var-19738
-                             public?-19739))
-                         (lambda (var-19748)
-                           (make-struct/no-tail
-                             (vector-ref %expanded-vtables 7)
-                             s-19465
-                             var-19748)))
-                       (if (eqv? type-19459 'call)
-                         (expand-application-4299
-                           (let ((e-19766 (car e-19462)))
+           (lambda () (scan body r w s m esew mod '()))
+           (lambda (exps)
+             (if (null? exps)
+               (build-void s)
+               (build-sequence
+                 s
+                 (let lp ((in exps) (out '()))
+                   (if (null? in)
+                     out
+                     (let ((e (car in)))
+                       (lp (cdr in) (cons (if (procedure? e) (e) e) 
out))))))))))))
+   (expand-install-global
+     (lambda (name e)
+       (build-global-definition
+         #f
+         name
+         (build-application
+           #f
+           (build-primref #f 'make-syntax-transformer)
+           (list (build-data #f name) (build-data #f 'macro) e)))))
+   (parse-when-list
+     (lambda (e when-list)
+       (let ((result (strip when-list '(()))))
+         (let lp ((l result))
+           (cond ((null? l) result)
+                 ((memq (car l) '(compile load eval expand)) (lp (cdr l)))
+                 (else (syntax-violation 'eval-when "invalid situation" e (car 
l))))))))
+   (syntax-type
+     (lambda (e r w s rib mod for-car?)
+       (cond ((symbol? e)
+              (let* ((n (id-var-name e w))
+                     (b (lookup n r mod))
+                     (type (car b))
+                     (key type))
+                (cond ((memv key '(lexical)) (values type (cdr b) e e w s mod))
+                      ((memv key '(global)) (values type n e e w s mod))
+                      ((memv key '(macro))
+                       (if for-car?
+                         (values type (cdr b) e e w s mod)
+                         (syntax-type
+                           (expand-macro (cdr b) e r w s rib mod)
+                           r
+                           '(())
+                           s
+                           rib
+                           mod
+                           #f)))
+                      (else (values type (cdr b) e e w s mod)))))
+             ((pair? e)
+              (let ((first (car e)))
+                (call-with-values
+                  (lambda () (syntax-type first r w s rib mod #t))
+                  (lambda (ftype fval fform fe fw fs fmod)
+                    (let ((key ftype))
+                      (cond ((memv key '(lexical)) (values 'lexical-call fval 
e e w s mod))
+                            ((memv key '(global))
+                             (values 'global-call (make-syntax-object fval w 
fmod) e e w s mod))
+                            ((memv key '(macro))
+                             (syntax-type
+                               (expand-macro fval e r w s rib mod)
+                               r
+                               '(())
+                               s
+                               rib
+                               mod
+                               for-car?))
+                            ((memv key '(module-ref))
                              (call-with-values
-                               (lambda ()
-                                 (syntax-type-4296
-                                   e-19766
-                                   r-19463
-                                   w-19464
-                                   (let ((props-19776
-                                           (source-properties
-                                             (if (if (vector? e-19766)
-                                                   (if (= (vector-length
-                                                            e-19766)
-                                                          4)
-                                                     (eq? (vector-ref
-                                                            e-19766
-                                                            0)
-                                                          'syntax-object)
-                                                     #f)
-                                                   #f)
-                                               (vector-ref e-19766 1)
-                                               e-19766))))
-                                     (if (pair? props-19776) props-19776 #f))
-                                   #f
-                                   mod-19466
-                                   #f))
-                               (lambda (type-19799
-                                        value-19800
-                                        form-19801
-                                        e-19802
-                                        w-19803
-                                        s-19804
-                                        mod-19805)
-                                 (expand-expr-4298
-                                   type-19799
-                                   value-19800
-                                   form-19801
-                                   e-19802
-                                   r-19463
-                                   w-19803
-                                   s-19804
-                                   mod-19805))))
-                           e-19462
-                           r-19463
-                           w-19464
-                           s-19465
-                           mod-19466)
-                         (if (eqv? type-19459 'begin-form)
-                           (let ((tmp-19815
-                                   ($sc-dispatch e-19462 '(_ any . each-any))))
-                             (if tmp-19815
-                               (@apply
-                                 (lambda (e1-19819 e2-19820)
-                                   (expand-sequence-4292
-                                     (cons e1-19819 e2-19820)
-                                     r-19463
-                                     w-19464
-                                     s-19465
-                                     mod-19466))
-                                 tmp-19815)
-                               (let ((tmp-19947 ($sc-dispatch e-19462 '(_))))
-                                 (if tmp-19947
-                                   (@apply
-                                     (lambda ()
-                                       (if (include-deprecated-features)
-                                         (begin
-                                           (issue-deprecation-warning
-                                             "Sequences of zero expressions 
are deprecated.  Use *unspecified*.")
-                                           (make-struct/no-tail
-                                             (vector-ref %expanded-vtables 0)
-                                             #f))
+                               (lambda () (fval e r w))
+                               (lambda (e r w s mod) (syntax-type e r w s rib 
mod for-car?))))
+                            ((memv key '(core)) (values 'core-form fval e e w 
s mod))
+                            ((memv key '(local-syntax))
+                             (values 'local-syntax-form fval e e w s mod))
+                            ((memv key '(begin)) (values 'begin-form #f e e w 
s mod))
+                            ((memv key '(eval-when)) (values 'eval-when-form 
#f e e w s mod))
+                            ((memv key '(define))
+                             (let* ((tmp e) (tmp-1 ($sc-dispatch tmp '(_ any 
any))))
+                               (if (and tmp-1 (apply (lambda (name val) (id? 
name)) tmp-1))
+                                 (apply (lambda (name val) (values 
'define-form name e val w s mod))
+                                        tmp-1)
+                                 (let ((tmp-1 ($sc-dispatch tmp '(_ (any . 
any) any . each-any))))
+                                   (if (and tmp-1
+                                            (apply (lambda (name args e1 e2)
+                                                     (and (id? name) 
(valid-bound-ids? (lambda-var-list args))))
+                                                   tmp-1))
+                                     (apply (lambda (name args e1 e2)
+                                              (values
+                                                'define-form
+                                                (wrap name w mod)
+                                                (wrap e w mod)
+                                                (decorate-source
+                                                  (cons '#(syntax-object 
lambda ((top)) (hygiene guile))
+                                                        (wrap (cons args (cons 
e1 e2)) w mod))
+                                                  s)
+                                                '(())
+                                                s
+                                                mod))
+                                            tmp-1)
+                                     (let ((tmp-1 ($sc-dispatch tmp '(_ any))))
+                                       (if (and tmp-1 (apply (lambda (name) 
(id? name)) tmp-1))
+                                         (apply (lambda (name)
+                                                  (values
+                                                    'define-form
+                                                    (wrap name w mod)
+                                                    (wrap e w mod)
+                                                    '(#(syntax-object if 
((top)) (hygiene guile)) #f #f)
+                                                    '(())
+                                                    s
+                                                    mod))
+                                                tmp-1)
                                          (syntax-violation
                                            #f
-                                           "sequence of zero expressions"
-                                           (wrap-4290
-                                             (begin
-                                               (if (if s-19465
-                                                     
(supports-source-properties?
-                                                       e-19462)
-                                                     #f)
-                                                 (set-source-properties!
-                                                   e-19462
-                                                   s-19465))
-                                               e-19462)
-                                             w-19464
-                                             mod-19466))))
-                                     tmp-19947)
-                                   (syntax-violation
-                                     #f
-                                     "source expression failed to match any 
pattern"
-                                     e-19462)))))
-                           (if (eqv? type-19459 'local-syntax-form)
-                             (expand-local-syntax-4302
-                               value-19460
-                               e-19462
-                               r-19463
-                               w-19464
-                               s-19465
-                               mod-19466
-                               expand-sequence-4292)
-                             (if (eqv? type-19459 'eval-when-form)
-                               (let ((tmp-20059
-                                       ($sc-dispatch
-                                         e-19462
-                                         '(_ each-any any . each-any))))
-                                 (if tmp-20059
-                                   (@apply
-                                     (lambda (x-20063 e1-20064 e2-20065)
-                                       (let ((when-list-20066
-                                               (parse-when-list-4295
-                                                 e-19462
-                                                 x-20063)))
-                                         (if (memq 'eval when-list-20066)
-                                           (expand-sequence-4292
-                                             (cons e1-20064 e2-20065)
-                                             r-19463
-                                             w-19464
-                                             s-19465
-                                             mod-19466)
-                                           (make-struct/no-tail
-                                             (vector-ref %expanded-vtables 0)
-                                             #f))))
-                                     tmp-20059)
-                                   (syntax-violation
-                                     #f
-                                     "source expression failed to match any 
pattern"
-                                     e-19462)))
-                               (if (if (eqv? type-19459 'define-form)
-                                     #t
-                                     (if (eqv? type-19459 'define-syntax-form)
-                                       #t
-                                       (eqv? type-19459
-                                             'define-syntax-parameter-form)))
+                                           "source expression failed to match 
any pattern"
+                                           tmp))))))))
+                            ((memv key '(define-syntax))
+                             (let* ((tmp-1 e) (tmp ($sc-dispatch tmp-1 '(_ any 
any))))
+                               (if (and tmp (apply (lambda (name val) (id? 
name)) tmp))
+                                 (apply (lambda (name val) (values 
'define-syntax-form name e val w s mod))
+                                        tmp)
+                                 (syntax-violation
+                                   #f
+                                   "source expression failed to match any 
pattern"
+                                   tmp-1))))
+                            ((memv key '(define-syntax-parameter))
+                             (let* ((tmp-1 e) (tmp ($sc-dispatch tmp-1 '(_ any 
any))))
+                               (if (and tmp (apply (lambda (name val) (id? 
name)) tmp))
+                                 (apply (lambda (name val)
+                                          (values 
'define-syntax-parameter-form name e val w s mod))
+                                        tmp)
                                  (syntax-violation
                                    #f
-                                   "definition in expression context, where 
definitions are not allowed,"
-                                   (wrap-4290
-                                     (begin
-                                       (if (if s-19465
-                                             (supports-source-properties?
-                                               form-19461)
-                                             #f)
-                                         (set-source-properties!
-                                           form-19461
-                                           s-19465))
-                                       form-19461)
-                                     w-19464
-                                     mod-19466))
-                                 (if (eqv? type-19459 'syntax)
+                                   "source expression failed to match any 
pattern"
+                                   tmp-1))))
+                            (else (values 'call #f e e w s mod))))))))
+             ((syntax-object? e)
+              (syntax-type
+                (syntax-object-expression e)
+                r
+                (join-wraps w (syntax-object-wrap e))
+                (or (source-annotation e) s)
+                rib
+                (or (syntax-object-module e) mod)
+                for-car?))
+             ((self-evaluating? e) (values 'constant #f e e w s mod))
+             (else (values 'other #f e e w s mod)))))
+   (expand
+     (lambda (e r w mod)
+       (call-with-values
+         (lambda () (syntax-type e r w (source-annotation e) #f mod #f))
+         (lambda (type value form e w s mod)
+           (expand-expr type value form e r w s mod)))))
+   (expand-expr
+     (lambda (type value form e r w s mod)
+       (let ((key type))
+         (cond ((memv key '(lexical)) (build-lexical-reference 'value s e 
value))
+               ((memv key '(core core-form)) (value e r w s mod))
+               ((memv key '(module-ref))
+                (call-with-values
+                  (lambda () (value e r w))
+                  (lambda (e r w s mod) (expand e r w mod))))
+               ((memv key '(lexical-call))
+                (expand-application
+                  (let ((id (car e)))
+                    (build-lexical-reference
+                      'fun
+                      (source-annotation id)
+                      (if (syntax-object? id) (syntax->datum id) id)
+                      value))
+                  e
+                  r
+                  w
+                  s
+                  mod))
+               ((memv key '(global-call))
+                (expand-application
+                  (build-global-reference
+                    (source-annotation (car e))
+                    (if (syntax-object? value) (syntax-object-expression 
value) value)
+                    (if (syntax-object? value) (syntax-object-module value) 
mod))
+                  e
+                  r
+                  w
+                  s
+                  mod))
+               ((memv key '(constant))
+                (build-data s (strip (source-wrap e w s mod) '(()))))
+               ((memv key '(global)) (build-global-reference s value mod))
+               ((memv key '(call))
+                (expand-application (expand (car e) r w mod) e r w s mod))
+               ((memv key '(begin-form))
+                (let* ((tmp e) (tmp-1 ($sc-dispatch tmp '(_ any . each-any))))
+                  (if tmp-1
+                    (apply (lambda (e1 e2) (expand-sequence (cons e1 e2) r w s 
mod))
+                           tmp-1)
+                    (let ((tmp-1 ($sc-dispatch tmp '(_))))
+                      (if tmp-1
+                        (apply (lambda ()
+                                 (if (include-deprecated-features)
+                                   (begin
+                                     (issue-deprecation-warning
+                                       "Sequences of zero expressions are 
deprecated.  Use *unspecified*.")
+                                     (expand-void))
                                    (syntax-violation
                                      #f
-                                     "reference to pattern variable outside 
syntax form"
-                                     (wrap-4290
-                                       (begin
-                                         (if (if s-19465
-                                               (supports-source-properties?
-                                                 e-19462)
-                                               #f)
-                                           (set-source-properties!
-                                             e-19462
-                                             s-19465))
-                                         e-19462)
-                                       w-19464
-                                       mod-19466))
-                                   (if (eqv? type-19459 'displaced-lexical)
-                                     (syntax-violation
-                                       #f
-                                       "reference to identifier outside its 
scope"
-                                       (wrap-4290
-                                         (begin
-                                           (if (if s-19465
-                                                 (supports-source-properties?
-                                                   e-19462)
-                                                 #f)
-                                             (set-source-properties!
-                                               e-19462
-                                               s-19465))
-                                           e-19462)
-                                         w-19464
-                                         mod-19466))
-                                     (syntax-violation
-                                       #f
-                                       "unexpected syntax"
-                                       (wrap-4290
-                                         (begin
-                                           (if (if s-19465
-                                                 (supports-source-properties?
-                                                   e-19462)
-                                                 #f)
-                                             (set-source-properties!
-                                               e-19462
-                                               s-19465))
-                                           e-19462)
-                                         w-19464
-                                         mod-19466))))))))))))))))))
-     (expand-application-4299
-       (lambda (x-20375
-                e-20376
-                r-20377
-                w-20378
-                s-20379
-                mod-20380)
-         (let ((tmp-20382
-                 ($sc-dispatch e-20376 '(any . each-any))))
-           (if tmp-20382
-             (@apply
-               (lambda (e0-20386 e1-20387)
-                 (let ((arg-exps-20393
-                         (map (lambda (e-20398)
-                                (call-with-values
-                                  (lambda ()
-                                    (syntax-type-4296
-                                      e-20398
-                                      r-20377
-                                      w-20378
-                                      (let ((props-20413
-                                              (source-properties
-                                                (if (if (vector? e-20398)
-                                                      (if (= (vector-length
-                                                               e-20398)
-                                                             4)
-                                                        (eq? (vector-ref
-                                                               e-20398
-                                                               0)
-                                                             'syntax-object)
-                                                        #f)
-                                                      #f)
-                                                  (vector-ref e-20398 1)
-                                                  e-20398))))
-                                        (if (pair? props-20413)
-                                          props-20413
-                                          #f))
-                                      #f
-                                      mod-20380
-                                      #f))
-                                  (lambda (type-20446
-                                           value-20447
-                                           form-20448
-                                           e-20449
-                                           w-20450
-                                           s-20451
-                                           mod-20452)
-                                    (expand-expr-4298
-                                      type-20446
-                                      value-20447
-                                      form-20448
-                                      e-20449
-                                      r-20377
-                                      w-20450
-                                      s-20451
-                                      mod-20452))))
-                              e1-20387)))
-                   (make-struct/no-tail
-                     (vector-ref %expanded-vtables 11)
-                     s-20379
-                     x-20375
-                     arg-exps-20393)))
-               tmp-20382)
-             (syntax-violation
-               #f
-               "source expression failed to match any pattern"
-               e-20376)))))
-     (expand-macro-4300
-       (lambda (p-20462
-                e-20463
-                r-20464
-                w-20465
-                s-20466
-                rib-20467
-                mod-20468)
-         (letrec*
-           ((rebuild-macro-output-20469
-              (lambda (x-20502 m-20503)
-                (if (pair? x-20502)
-                  (let ((e-20507
-                          (cons (rebuild-macro-output-20469
-                                  (car x-20502)
-                                  m-20503)
-                                (rebuild-macro-output-20469
-                                  (cdr x-20502)
-                                  m-20503))))
-                    (begin
-                      (if (if s-20466
-                            (supports-source-properties? e-20507)
-                            #f)
-                        (set-source-properties! e-20507 s-20466))
-                      e-20507))
-                  (if (if (vector? x-20502)
-                        (if (= (vector-length x-20502) 4)
-                          (eq? (vector-ref x-20502 0) 'syntax-object)
-                          #f)
-                        #f)
-                    (let ((w-20523 (vector-ref x-20502 2)))
-                      (let ((ms-20524 (car w-20523))
-                            (ss-20525 (cdr w-20523)))
-                        (if (if (pair? ms-20524) (eq? (car ms-20524) #f) #f)
-                          (let ((expression-20533 (vector-ref x-20502 1))
-                                (wrap-20534
-                                  (cons (cdr ms-20524)
-                                        (if rib-20467
-                                          (cons rib-20467 (cdr ss-20525))
-                                          (cdr ss-20525))))
-                                (module-20535 (vector-ref x-20502 3)))
-                            (vector
-                              'syntax-object
-                              expression-20533
-                              wrap-20534
-                              module-20535))
-                          (let ((expression-20545
-                                  (let ((e-20550 (vector-ref x-20502 1)))
-                                    (begin
-                                      (if (if s-20466
-                                            (supports-source-properties?
-                                              e-20550)
-                                            #f)
-                                        (set-source-properties!
-                                          e-20550
-                                          s-20466))
-                                      e-20550)))
-                                (wrap-20546
-                                  (cons (cons m-20503 ms-20524)
-                                        (if rib-20467
-                                          (cons rib-20467
-                                                (cons 'shift ss-20525))
-                                          (cons 'shift ss-20525))))
-                                (module-20547 (vector-ref x-20502 3)))
-                            (vector
-                              'syntax-object
-                              expression-20545
-                              wrap-20546
-                              module-20547)))))
-                    (if (vector? x-20502)
-                      (let ((n-20562 (vector-length x-20502)))
-                        (let ((v-20563
-                                (let ((e-20571 (make-vector n-20562)))
-                                  (begin
-                                    (if (if s-20466
-                                          (supports-source-properties? e-20571)
-                                          #f)
-                                      (set-source-properties! e-20571 s-20466))
-                                    e-20571))))
-                          (letrec*
-                            ((loop-20564
-                               (lambda (i-20616)
-                                 (if (= i-20616 n-20562)
-                                   v-20563
-                                   (begin
-                                     (vector-set!
-                                       v-20563
-                                       i-20616
-                                       (rebuild-macro-output-20469
-                                         (vector-ref x-20502 i-20616)
-                                         m-20503))
-                                     (loop-20564 (#{1+}# i-20616)))))))
-                            (loop-20564 0))))
-                      (if (symbol? x-20502)
-                        (syntax-violation
-                          #f
-                          "encountered raw symbol in macro output"
-                          (let ((s-20622 (cdr w-20465)))
-                            (wrap-4290
-                              (begin
-                                (if (if s-20622
-                                      (supports-source-properties? e-20463)
-                                      #f)
-                                  (set-source-properties! e-20463 s-20622))
-                                e-20463)
-                              w-20465
-                              mod-20468))
-                          x-20502)
-                        (begin
-                          (if (if s-20466
-                                (supports-source-properties? x-20502)
-                                #f)
-                            (set-source-properties! x-20502 s-20466))
-                          x-20502))))))))
-           (with-fluids
-             ((transformer-environment-4283
-                (lambda (k-20470)
-                  (k-20470
-                    e-20463
-                    r-20464
-                    w-20465
-                    s-20466
-                    rib-20467
-                    mod-20468))))
-             (rebuild-macro-output-20469
-               (p-20462
-                 (let ((w-20477
-                         (cons (cons #f (car w-20465))
-                               (cons 'shift (cdr w-20465)))))
-                   (wrap-4290
-                     (begin
-                       (if (if s-20466
-                             (supports-source-properties? e-20463)
-                             #f)
-                         (set-source-properties! e-20463 s-20466))
-                       e-20463)
-                     w-20477
-                     mod-20468)))
-               (gensym
-                 (string-append "m-" (session-id-4222) "-")))))))
-     (expand-body-4301
-       (lambda (body-20654
-                outer-form-20655
-                r-20656
-                w-20657
-                mod-20658)
-         (let ((r-20659
-                 (cons '("placeholder" placeholder) r-20656)))
-           (let ((ribcage-20660 (vector 'ribcage '() '() '())))
-             (let ((w-20661
-                     (cons (car w-20657)
-                           (cons ribcage-20660 (cdr w-20657)))))
-               (letrec*
-                 ((parse-20662
-                    (lambda (body-20675
-                             ids-20676
-                             labels-20677
-                             var-ids-20678
-                             vars-20679
-                             vals-20680
-                             bindings-20681)
-                      (if (null? body-20675)
-                        (syntax-violation
-                          #f
-                          "no expressions in body"
-                          outer-form-20655)
-                        (let ((e-20682 (cdr (car body-20675)))
-                              (er-20683 (car (car body-20675))))
-                          (call-with-values
-                            (lambda ()
-                              (syntax-type-4296
-                                e-20682
-                                er-20683
-                                '(())
-                                (let ((props-20692
-                                        (source-properties
-                                          (if (if (vector? er-20683)
-                                                (if (= (vector-length er-20683)
-                                                       4)
-                                                  (eq? (vector-ref er-20683 0)
-                                                       'syntax-object)
-                                                  #f)
-                                                #f)
-                                            (vector-ref er-20683 1)
-                                            er-20683))))
-                                  (if (pair? props-20692) props-20692 #f))
-                                ribcage-20660
-                                mod-20658
-                                #f))
-                            (lambda (type-20715
-                                     value-20716
-                                     form-20717
-                                     e-20718
-                                     w-20719
-                                     s-20720
-                                     mod-20721)
-                              (if (eqv? type-20715 'define-form)
-                                (let ((id-20729
-                                        (wrap-4290
-                                          value-20716
-                                          w-20719
-                                          mod-20721))
-                                      (label-20730
-                                        (string-append
-                                          "l-"
-                                          (session-id-4222)
-                                          (symbol->string (gensym "-")))))
-                                  (let ((var-20731
-                                          (let ((id-20791
-                                                  (if (if (vector? id-20729)
-                                                        (if (= (vector-length
-                                                                 id-20729)
-                                                               4)
-                                                          (eq? (vector-ref
-                                                                 id-20729
-                                                                 0)
-                                                               'syntax-object)
-                                                          #f)
-                                                        #f)
-                                                    (vector-ref id-20729 1)
-                                                    id-20729)))
-                                            (gensym
-                                              (string-append
-                                                (symbol->string id-20791)
-                                                "-")))))
-                                    (begin
-                                      (let ((update-20781
-                                              (cons (vector-ref id-20729 1)
-                                                    (vector-ref
-                                                      ribcage-20660
-                                                      1))))
-                                        (vector-set!
-                                          ribcage-20660
-                                          1
-                                          update-20781))
-                                      (let ((update-20783
-                                              (cons (car (vector-ref
-                                                           id-20729
-                                                           2))
-                                                    (vector-ref
-                                                      ribcage-20660
-                                                      2))))
-                                        (vector-set!
-                                          ribcage-20660
-                                          2
-                                          update-20783))
-                                      (let ((update-20785
-                                              (cons label-20730
-                                                    (vector-ref
-                                                      ribcage-20660
-                                                      3))))
-                                        (vector-set!
-                                          ribcage-20660
-                                          3
-                                          update-20785))
-                                      (parse-20662
-                                        (cdr body-20675)
-                                        (cons id-20729 ids-20676)
-                                        (cons label-20730 labels-20677)
-                                        (cons id-20729 var-ids-20678)
-                                        (cons var-20731 vars-20679)
-                                        (cons (cons er-20683
-                                                    (wrap-4290
-                                                      e-20718
-                                                      w-20719
-                                                      mod-20721))
-                                              vals-20680)
-                                        (cons (cons 'lexical var-20731)
-                                              bindings-20681)))))
-                                (if (if (eqv? type-20715 'define-syntax-form)
-                                      #t
-                                      (eqv? type-20715
-                                            'define-syntax-parameter-form))
-                                  (let ((id-20827
-                                          (wrap-4290
-                                            value-20716
-                                            w-20719
-                                            mod-20721))
-                                        (label-20828
-                                          (string-append
-                                            "l-"
-                                            (session-id-4222)
-                                            (symbol->string (gensym "-")))))
-                                    (begin
-                                      (let ((update-20878
-                                              (cons (vector-ref id-20827 1)
-                                                    (vector-ref
-                                                      ribcage-20660
-                                                      1))))
-                                        (vector-set!
-                                          ribcage-20660
-                                          1
-                                          update-20878))
-                                      (let ((update-20880
-                                              (cons (car (vector-ref
-                                                           id-20827
-                                                           2))
-                                                    (vector-ref
-                                                      ribcage-20660
-                                                      2))))
-                                        (vector-set!
-                                          ribcage-20660
-                                          2
-                                          update-20880))
-                                      (let ((update-20882
-                                              (cons label-20828
-                                                    (vector-ref
-                                                      ribcage-20660
-                                                      3))))
-                                        (vector-set!
-                                          ribcage-20660
-                                          3
-                                          update-20882))
-                                      (parse-20662
-                                        (cdr body-20675)
-                                        (cons id-20827 ids-20676)
-                                        (cons label-20828 labels-20677)
-                                        var-ids-20678
-                                        vars-20679
-                                        vals-20680
-                                        (cons (cons 'macro
-                                                    (cons er-20683
-                                                          (wrap-4290
-                                                            e-20718
-                                                            w-20719
-                                                            mod-20721)))
-                                              bindings-20681))))
-                                  (if (eqv? type-20715 'begin-form)
-                                    (let ((tmp-20893
-                                            ($sc-dispatch
-                                              e-20718
-                                              '(_ . each-any))))
-                                      (if tmp-20893
-                                        (@apply
-                                          (lambda (e1-20897)
-                                            (parse-20662
-                                              (letrec*
-                                                ((f-20898
-                                                   (lambda (forms-20961)
-                                                     (if (null? forms-20961)
-                                                       (cdr body-20675)
-                                                       (cons (cons er-20683
-                                                                   (wrap-4290
-                                                                     (car 
forms-20961)
-                                                                     w-20719
-                                                                     
mod-20721))
-                                                             (f-20898
-                                                               (cdr 
forms-20961)))))))
-                                                (f-20898 e1-20897))
-                                              ids-20676
-                                              labels-20677
-                                              var-ids-20678
-                                              vars-20679
-                                              vals-20680
-                                              bindings-20681))
-                                          tmp-20893)
-                                        (syntax-violation
-                                          #f
-                                          "source expression failed to match 
any pattern"
-                                          e-20718)))
-                                    (if (eqv? type-20715 'local-syntax-form)
-                                      (expand-local-syntax-4302
-                                        value-20716
-                                        e-20718
-                                        er-20683
-                                        w-20719
-                                        s-20720
-                                        mod-20721
-                                        (lambda (forms-20978
-                                                 er-20979
-                                                 w-20980
-                                                 s-20981
-                                                 mod-20982)
-                                          (parse-20662
-                                            (letrec*
-                                              ((f-20983
-                                                 (lambda (forms-21046)
-                                                   (if (null? forms-21046)
-                                                     (cdr body-20675)
-                                                     (cons (cons er-20979
-                                                                 (wrap-4290
-                                                                   (car 
forms-21046)
-                                                                   w-20980
-                                                                   mod-20982))
-                                                           (f-20983
-                                                             (cdr 
forms-21046)))))))
-                                              (f-20983 forms-20978))
-                                            ids-20676
-                                            labels-20677
-                                            var-ids-20678
-                                            vars-20679
-                                            vals-20680
-                                            bindings-20681)))
-                                      (if (null? ids-20676)
-                                        (let ((exps-21053
-                                                (map (lambda (x-21054)
-                                                       (let ((e-21057
-                                                               (cdr x-21054))
-                                                             (r-21058
-                                                               (car x-21054)))
-                                                         (call-with-values
-                                                           (lambda ()
-                                                             (syntax-type-4296
-                                                               e-21057
-                                                               r-21058
-                                                               '(())
-                                                               (let 
((props-21065
-                                                                       
(source-properties
-                                                                         (if 
(if (vector?
-                                                                               
    e-21057)
-                                                                               
(if (= (vector-length
-                                                                               
         e-21057)
-                                                                               
       4)
-                                                                               
  (eq? (vector-ref
-                                                                               
         e-21057
-                                                                               
         0)
-                                                                               
       'syntax-object)
-                                                                               
  #f)
-                                                                               
#f)
-                                                                           
(vector-ref
-                                                                             
e-21057
-                                                                             1)
-                                                                           
e-21057))))
-                                                                 (if (pair? 
props-21065)
-                                                                   props-21065
-                                                                   #f))
-                                                               #f
-                                                               mod-20721
-                                                               #f))
-                                                           (lambda (type-21088
-                                                                    value-21089
-                                                                    form-21090
-                                                                    e-21091
-                                                                    w-21092
-                                                                    s-21093
-                                                                    mod-21094)
-                                                             (expand-expr-4298
-                                                               type-21088
-                                                               value-21089
-                                                               form-21090
-                                                               e-21091
-                                                               r-21058
-                                                               w-21092
-                                                               s-21093
-                                                               mod-21094)))))
-                                                     (cons (cons er-20683
-                                                                 (wrap-4290
-                                                                   (begin
-                                                                     (if (if 
s-20720
-                                                                           
(supports-source-properties?
-                                                                             
e-20718)
-                                                                           #f)
-                                                                       
(set-source-properties!
-                                                                         
e-20718
-                                                                         
s-20720))
-                                                                     e-20718)
-                                                                   w-20719
-                                                                   mod-20721))
-                                                           (cdr body-20675)))))
-                                          (if (null? (cdr exps-21053))
-                                            (car exps-21053)
-                                            (make-struct/no-tail
-                                              (vector-ref %expanded-vtables 12)
-                                              #f
-                                              exps-21053)))
-                                        (begin
-                                          (if (not (valid-bound-ids?-4287
-                                                     ids-20676))
-                                            (syntax-violation
-                                              #f
-                                              "invalid or duplicate identifier 
in definition"
-                                              outer-form-20655))
-                                          (letrec*
-                                            ((loop-21197
-                                               (lambda (bs-21200
-                                                        er-cache-21201
-                                                        r-cache-21202)
-                                                 (if (not (null? bs-21200))
-                                                   (let ((b-21203
-                                                           (car bs-21200)))
-                                                     (if (eq? (car b-21203)
-                                                              'macro)
-                                                       (let ((er-21205
-                                                               (car (cdr 
b-21203))))
-                                                         (let ((r-cache-21206
-                                                                 (if (eq? 
er-21205
-                                                                          
er-cache-21201)
-                                                                   
r-cache-21202
-                                                                   
(macros-only-env-4257
-                                                                     
er-21205))))
-                                                           (begin
-                                                             (set-cdr!
-                                                               b-21203
-                                                               
(eval-local-transformer-4303
-                                                                 (let ((e-21249
-                                                                         (cdr 
(cdr b-21203))))
-                                                                   
(call-with-values
-                                                                     (lambda ()
-                                                                       
(syntax-type-4296
-                                                                         
e-21249
-                                                                         
r-cache-21206
-                                                                         '(())
-                                                                         (let 
((props-21259
-                                                                               
  (source-properties
-                                                                               
    (if (if (vector?
-                                                                               
              e-21249)
-                                                                               
          (if (= (vector-length
-                                                                               
                   e-21249)
-                                                                               
                 4)
-                                                                               
            (eq? (vector-ref
-                                                                               
                   e-21249
-                                                                               
                   0)
-                                                                               
                 'syntax-object)
-                                                                               
            #f)
-                                                                               
          #f)
-                                                                               
      (vector-ref
-                                                                               
        e-21249
-                                                                               
        1)
-                                                                               
      e-21249))))
-                                                                           (if 
(pair? props-21259)
-                                                                             
props-21259
-                                                                             
#f))
-                                                                         #f
-                                                                         
mod-20721
-                                                                         #f))
-                                                                     (lambda 
(type-21282
-                                                                              
value-21283
-                                                                              
form-21284
-                                                                              
e-21285
-                                                                              
w-21286
-                                                                              
s-21287
-                                                                              
mod-21288)
-                                                                       
(expand-expr-4298
-                                                                         
type-21282
-                                                                         
value-21283
-                                                                         
form-21284
-                                                                         
e-21285
-                                                                         
r-cache-21206
-                                                                         
w-21286
-                                                                         
s-21287
-                                                                         
mod-21288))))
-                                                                 mod-20721))
-                                                             (loop-21197
-                                                               (cdr bs-21200)
-                                                               er-21205
-                                                               
r-cache-21206))))
-                                                       (loop-21197
-                                                         (cdr bs-21200)
-                                                         er-cache-21201
-                                                         r-cache-21202)))))))
-                                            (loop-21197 bindings-20681 #f #f))
-                                          (set-cdr!
-                                            r-20659
-                                            (extend-env-4255
-                                              labels-20677
-                                              bindings-20681
-                                              (cdr r-20659)))
-                                          (let ((ids-21471
-                                                  (reverse
-                                                    (map syntax->datum
-                                                         var-ids-20678)))
-                                                (vars-21472
-                                                  (reverse vars-20679))
-                                                (val-exps-21473
-                                                  (map (lambda (x-21560)
-                                                         (let ((e-21563
-                                                                 (cdr x-21560))
-                                                               (r-21564
-                                                                 (car 
x-21560)))
-                                                           (call-with-values
-                                                             (lambda ()
-                                                               
(syntax-type-4296
-                                                                 e-21563
-                                                                 r-21564
-                                                                 '(())
-                                                                 (let 
((props-21571
-                                                                         
(source-properties
-                                                                           (if 
(if (vector?
-                                                                               
      e-21563)
-                                                                               
  (if (= (vector-length
-                                                                               
           e-21563)
-                                                                               
         4)
-                                                                               
    (eq? (vector-ref
-                                                                               
           e-21563
-                                                                               
           0)
-                                                                               
         'syntax-object)
-                                                                               
    #f)
-                                                                               
  #f)
-                                                                             
(vector-ref
-                                                                               
e-21563
-                                                                               
1)
-                                                                             
e-21563))))
-                                                                   (if (pair? 
props-21571)
-                                                                     
props-21571
-                                                                     #f))
-                                                                 #f
-                                                                 mod-20721
-                                                                 #f))
-                                                             (lambda 
(type-21594
-                                                                      
value-21595
-                                                                      
form-21596
-                                                                      e-21597
-                                                                      w-21598
-                                                                      s-21599
-                                                                      
mod-21600)
-                                                               
(expand-expr-4298
-                                                                 type-21594
-                                                                 value-21595
-                                                                 form-21596
-                                                                 e-21597
-                                                                 r-21564
-                                                                 w-21598
-                                                                 s-21599
-                                                                 mod-21600)))))
-                                                       (reverse vals-20680)))
-                                                (body-exp-21474
-                                                  (let ((exps-21478
-                                                          (map (lambda 
(x-21479)
-                                                                 (let ((e-21482
-                                                                         (cdr 
x-21479))
-                                                                       (r-21483
-                                                                         (car 
x-21479)))
-                                                                   
(call-with-values
-                                                                     (lambda ()
-                                                                       
(syntax-type-4296
-                                                                         
e-21482
-                                                                         
r-21483
-                                                                         '(())
-                                                                         (let 
((props-21490
-                                                                               
  (source-properties
-                                                                               
    (if (if (vector?
-                                                                               
              e-21482)
-                                                                               
          (if (= (vector-length
-                                                                               
                   e-21482)
-                                                                               
                 4)
-                                                                               
            (eq? (vector-ref
-                                                                               
                   e-21482
-                                                                               
                   0)
-                                                                               
                 'syntax-object)
-                                                                               
            #f)
-                                                                               
          #f)
-                                                                               
      (vector-ref
-                                                                               
        e-21482
-                                                                               
        1)
-                                                                               
      e-21482))))
-                                                                           (if 
(pair? props-21490)
-                                                                             
props-21490
-                                                                             
#f))
-                                                                         #f
-                                                                         
mod-20721
-                                                                         #f))
-                                                                     (lambda 
(type-21513
-                                                                              
value-21514
-                                                                              
form-21515
-                                                                              
e-21516
-                                                                              
w-21517
-                                                                              
s-21518
-                                                                              
mod-21519)
-                                                                       
(expand-expr-4298
-                                                                         
type-21513
-                                                                         
value-21514
-                                                                         
form-21515
-                                                                         
e-21516
-                                                                         
r-21483
-                                                                         
w-21517
-                                                                         
s-21518
-                                                                         
mod-21519)))))
-                                                               (cons (cons 
er-20683
-                                                                           
(wrap-4290
-                                                                             
(begin
-                                                                               
(if (if s-20720
-                                                                               
      (supports-source-properties?
-                                                                               
        e-20718)
-                                                                               
      #f)
-                                                                               
  (set-source-properties!
-                                                                               
    e-20718
-                                                                               
    s-20720))
-                                                                               
e-20718)
-                                                                             
w-20719
-                                                                             
mod-20721))
-                                                                     (cdr 
body-20675)))))
-                                                    (if (null? (cdr 
exps-21478))
-                                                      (car exps-21478)
-                                                      (make-struct/no-tail
-                                                        (vector-ref
-                                                          %expanded-vtables
-                                                          12)
-                                                        #f
-                                                        exps-21478)))))
-                                            (if (null? vars-21472)
-                                              body-exp-21474
-                                              (begin
-                                                (for-each
-                                                  maybe-name-value!-4226
-                                                  ids-21471
-                                                  val-exps-21473)
-                                                (make-struct/no-tail
-                                                  (vector-ref
-                                                    %expanded-vtables
-                                                    16)
-                                                  #f
-                                                  #t
-                                                  ids-21471
-                                                  vars-21472
-                                                  val-exps-21473
-                                                  
body-exp-21474)))))))))))))))))
-                 (parse-20662
-                   (map (lambda (x-20665)
-                          (cons r-20659
-                                (wrap-4290 x-20665 w-20661 mod-20658)))
-                        body-20654)
-                   '()
-                   '()
-                   '()
-                   '()
-                   '()
-                   '())))))))
-     (expand-local-syntax-4302
-       (lambda (rec?-21610
-                e-21611
-                r-21612
-                w-21613
-                s-21614
-                mod-21615
-                k-21616)
-         (let ((tmp-21618
-                 ($sc-dispatch
-                   e-21611
-                   '(_ #(each (any any)) any . each-any))))
-           (if tmp-21618
-             (@apply
-               (lambda (id-21620 val-21621 e1-21622 e2-21623)
-                 (if (not (valid-bound-ids?-4287 id-21620))
-                   (syntax-violation
-                     #f
-                     "duplicate bound keyword"
-                     e-21611)
-                   (let ((labels-21713 (gen-labels-4264 id-21620)))
-                     (let ((new-w-21714
-                             (make-binding-wrap-4275
-                               id-21620
-                               labels-21713
-                               w-21613)))
-                       (k-21616
-                         (cons e1-21622 e2-21623)
-                         (extend-env-4255
-                           labels-21713
-                           (let ((trans-r-21750
-                                   (macros-only-env-4257 r-21612)))
-                             (begin
-                               (if rec?-21610 new-w-21714 w-21613)
-                               (map (lambda (x-21751)
-                                      (cons 'macro
-                                            (eval-local-transformer-4303
-                                              (call-with-values
-                                                (lambda ()
-                                                  (syntax-type-4296
-                                                    x-21751
-                                                    trans-r-21750
-                                                    (values
-                                                      (if rec?-21610
-                                                        new-w-21714
-                                                        w-21613))
-                                                    (let ((props-21811
-                                                            (source-properties
-                                                              (if (if (vector?
-                                                                        
x-21751)
-                                                                    (if (= 
(vector-length
-                                                                             
x-21751)
-                                                                           4)
-                                                                      (eq? 
(vector-ref
-                                                                             
x-21751
-                                                                             0)
-                                                                           
'syntax-object)
-                                                                      #f)
-                                                                    #f)
-                                                                (vector-ref
-                                                                  x-21751
-                                                                  1)
-                                                                x-21751))))
-                                                      (if (pair? props-21811)
-                                                        props-21811
-                                                        #f))
-                                                    #f
-                                                    mod-21615
-                                                    #f))
-                                                (lambda (type-21844
-                                                         value-21845
-                                                         form-21846
-                                                         e-21847
-                                                         w-21848
-                                                         s-21849
-                                                         mod-21850)
-                                                  (expand-expr-4298
-                                                    type-21844
-                                                    value-21845
-                                                    form-21846
-                                                    e-21847
-                                                    trans-r-21750
-                                                    w-21848
-                                                    s-21849
-                                                    mod-21850)))
-                                              mod-21615)))
-                                    val-21621)))
-                           r-21612)
-                         new-w-21714
-                         s-21614
-                         mod-21615)))))
-               tmp-21618)
-             (syntax-violation
-               #f
-               "bad local syntax definition"
-               (wrap-4290
-                 (begin
-                   (if (if s-21614
-                         (supports-source-properties? e-21611)
-                         #f)
-                     (set-source-properties! e-21611 s-21614))
-                   e-21611)
-                 w-21613
-                 mod-21615))))))
-     (eval-local-transformer-4303
-       (lambda (expanded-22016 mod-22017)
-         (let ((p-22018 (primitive-eval expanded-22016)))
-           (if (procedure? p-22018)
-             p-22018
-             (syntax-violation
-               #f
-               "nonprocedure transformer"
-               p-22018)))))
-     (ellipsis?-4305
-       (lambda (x-4941)
-         (if (if (if (vector? x-4941)
-                   (if (= (vector-length x-4941) 4)
-                     (eq? (vector-ref x-4941 0) 'syntax-object)
-                     #f)
-                   #f)
-               (symbol? (vector-ref x-4941 1))
-               #f)
-           (if (eq? (if (if (vector? x-4941)
-                          (if (= (vector-length x-4941) 4)
-                            (eq? (vector-ref x-4941 0) 'syntax-object)
-                            #f)
-                          #f)
-                      (vector-ref x-4941 1)
-                      x-4941)
-                    (if (if (= (vector-length
-                                 '#(syntax-object
-                                    ...
-                                    ((top)
-                                     #(ribcage () () ())
-                                     #(ribcage () () ())
-                                     #(ribcage #(x) #((top)) #("l-*-2265"))
-                                     #(ribcage
-                                       (lambda-var-list
-                                         gen-var
-                                         strip
-                                         expand-lambda-case
-                                         lambda*-formals
-                                         expand-simple-lambda
-                                         lambda-formals
-                                         ellipsis?
-                                         expand-void
-                                         eval-local-transformer
-                                         expand-local-syntax
-                                         expand-body
-                                         expand-macro
-                                         expand-application
-                                         expand-expr
-                                         expand
-                                         syntax-type
-                                         parse-when-list
-                                         expand-install-global
-                                         expand-top-sequence
-                                         expand-sequence
-                                         source-wrap
-                                         wrap
-                                         bound-id-member?
-                                         distinct-bound-ids?
-                                         valid-bound-ids?
-                                         bound-id=?
-                                         free-id=?
-                                         with-transformer-environment
-                                         transformer-environment
-                                         resolve-identifier
-                                         locally-bound-identifiers
-                                         id-var-name
-                                         same-marks?
-                                         join-marks
-                                         join-wraps
-                                         smart-append
-                                         make-binding-wrap
-                                         extend-ribcage!
-                                         make-empty-ribcage
-                                         new-mark
-                                         anti-mark
-                                         the-anti-mark
-                                         top-marked?
-                                         top-wrap
-                                         empty-wrap
-                                         set-ribcage-labels!
-                                         set-ribcage-marks!
-                                         set-ribcage-symnames!
-                                         ribcage-labels
-                                         ribcage-marks
-                                         ribcage-symnames
-                                         ribcage?
-                                         make-ribcage
-                                         gen-labels
-                                         gen-label
-                                         make-rename
-                                         rename-marks
-                                         rename-new
-                                         rename-old
-                                         subst-rename?
-                                         wrap-subst
-                                         wrap-marks
-                                         make-wrap
-                                         id-sym-name&marks
-                                         id-sym-name
-                                         id?
-                                         nonsymbol-id?
-                                         global-extend
-                                         lookup
-                                         macros-only-env
-                                         extend-var-env
-                                         extend-env
-                                         null-env
-                                         binding-value
-                                         binding-type
-                                         make-binding
-                                         arg-check
-                                         source-annotation
-                                         no-source
-                                         set-syntax-object-module!
-                                         set-syntax-object-wrap!
-                                         set-syntax-object-expression!
-                                         syntax-object-module
-                                         syntax-object-wrap
-                                         syntax-object-expression
-                                         syntax-object?
-                                         make-syntax-object
-                                         build-lexical-var
-                                         build-letrec
-                                         build-named-let
-                                         build-let
-                                         build-sequence
-                                         build-data
-                                         build-primref
-                                         build-lambda-case
-                                         build-case-lambda
-                                         build-simple-lambda
-                                         build-global-definition
-                                         build-global-assignment
-                                         build-global-reference
-                                         analyze-variable
-                                         build-lexical-assignment
-                                         build-lexical-reference
-                                         build-dynlet
-                                         build-conditional
-                                         build-application
-                                         build-void
-                                         maybe-name-value!
-                                         decorate-source
-                                         get-global-definition-hook
-                                         put-global-definition-hook
-                                         session-id
-                                         local-eval-hook
-                                         top-level-eval-hook
-                                         fx<
-                                         fx=
-                                         fx-
-                                         fx+
-                                         set-lambda-meta!
-                                         lambda-meta
-                                         lambda?
-                                         make-dynlet
-                                         make-letrec
-                                         make-let
-                                         make-lambda-case
-                                         make-lambda
-                                         make-sequence
-                                         make-application
-                                         make-conditional
-                                         make-toplevel-define
-                                         make-toplevel-set
-                                         make-toplevel-ref
-                                         make-module-set
-                                         make-module-ref
-                                         make-lexical-set
-                                         make-lexical-ref
-                                         make-primitive-ref
-                                         make-const
-                                         make-void)
-                                       ((top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top)
-                                        (top))
-                                       ("l-*-476"
-                                        "l-*-474"
-                                        "l-*-472"
-                                        "l-*-470"
-                                        "l-*-468"
-                                        "l-*-466"
-                                        "l-*-464"
-                                        "l-*-462"
-                                        "l-*-460"
-                                        "l-*-458"
-                                        "l-*-456"
-                                        "l-*-454"
-                                        "l-*-452"
-                                        "l-*-450"
-                                        "l-*-448"
-                                        "l-*-446"
-                                        "l-*-444"
-                                        "l-*-442"
-                                        "l-*-440"
-                                        "l-*-438"
-                                        "l-*-436"
-                                        "l-*-434"
-                                        "l-*-432"
-                                        "l-*-430"
-                                        "l-*-428"
-                                        "l-*-426"
-                                        "l-*-424"
-                                        "l-*-422"
-                                        "l-*-420"
-                                        "l-*-418"
-                                        "l-*-416"
-                                        "l-*-414"
-                                        "l-*-412"
-                                        "l-*-410"
-                                        "l-*-408"
-                                        "l-*-406"
-                                        "l-*-404"
-                                        "l-*-402"
-                                        "l-*-400"
-                                        "l-*-399"
-                                        "l-*-397"
-                                        "l-*-394"
-                                        "l-*-393"
-                                        "l-*-392"
-                                        "l-*-390"
-                                        "l-*-389"
-                                        "l-*-387"
-                                        "l-*-385"
-                                        "l-*-383"
-                                        "l-*-381"
-                                        "l-*-379"
-                                        "l-*-377"
-                                        "l-*-375"
-                                        "l-*-373"
-                                        "l-*-370"
-                                        "l-*-368"
-                                        "l-*-367"
-                                        "l-*-365"
-                                        "l-*-363"
-                                        "l-*-361"
-                                        "l-*-359"
-                                        "l-*-358"
-                                        "l-*-357"
-                                        "l-*-356"
-                                        "l-*-354"
-                                        "l-*-353"
-                                        "l-*-350"
-                                        "l-*-348"
-                                        "l-*-346"
-                                        "l-*-344"
-                                        "l-*-342"
-                                        "l-*-340"
-                                        "l-*-338"
-                                        "l-*-337"
-                                        "l-*-336"
-                                        "l-*-334"
-                                        "l-*-332"
-                                        "l-*-331"
-                                        "l-*-328"
-                                        "l-*-327"
-                                        "l-*-325"
-                                        "l-*-323"
-                                        "l-*-321"
-                                        "l-*-319"
-                                        "l-*-317"
-                                        "l-*-315"
-                                        "l-*-313"
-                                        "l-*-311"
-                                        "l-*-309"
-                                        "l-*-306"
-                                        "l-*-304"
-                                        "l-*-302"
-                                        "l-*-300"
-                                        "l-*-298"
-                                        "l-*-296"
-                                        "l-*-294"
-                                        "l-*-292"
-                                        "l-*-290"
-                                        "l-*-288"
-                                        "l-*-286"
-                                        "l-*-284"
-                                        "l-*-282"
-                                        "l-*-280"
-                                        "l-*-278"
-                                        "l-*-276"
-                                        "l-*-274"
-                                        "l-*-272"
-                                        "l-*-270"
-                                        "l-*-268"
-                                        "l-*-266"
-                                        "l-*-264"
-                                        "l-*-262"
-                                        "l-*-260"
-                                        "l-*-258"
-                                        "l-*-256"
-                                        "l-*-255"
-                                        "l-*-254"
-                                        "l-*-253"
-                                        "l-*-252"
-                                        "l-*-250"
-                                        "l-*-248"
-                                        "l-*-246"
-                                        "l-*-243"
-                                        "l-*-241"
-                                        "l-*-239"
-                                        "l-*-237"
-                                        "l-*-235"
-                                        "l-*-233"
-                                        "l-*-231"
-                                        "l-*-229"
-                                        "l-*-227"
-                                        "l-*-225"
-                                        "l-*-223"
-                                        "l-*-221"
-                                        "l-*-219"
-                                        "l-*-217"
-                                        "l-*-215"
-                                        "l-*-213"
-                                        "l-*-211"
-                                        "l-*-209"))
-                                     #(ribcage
-                                       (define-structure
-                                         define-expansion-accessors
-                                         define-expansion-constructors)
-                                       ((top) (top) (top))
-                                       ("l-*-47" "l-*-46" "l-*-45")))
-                                    (hygiene guile)))
-                               4)
-                          #t
-                          #f)
-                      '...
-                      '#(syntax-object
-                         ...
-                         ((top)
-                          #(ribcage () () ())
-                          #(ribcage () () ())
-                          #(ribcage #(x) #((top)) #("l-*-2265"))
-                          #(ribcage
-                            (lambda-var-list
-                              gen-var
-                              strip
-                              expand-lambda-case
-                              lambda*-formals
-                              expand-simple-lambda
-                              lambda-formals
-                              ellipsis?
-                              expand-void
-                              eval-local-transformer
-                              expand-local-syntax
-                              expand-body
-                              expand-macro
-                              expand-application
-                              expand-expr
-                              expand
-                              syntax-type
-                              parse-when-list
-                              expand-install-global
-                              expand-top-sequence
-                              expand-sequence
-                              source-wrap
-                              wrap
-                              bound-id-member?
-                              distinct-bound-ids?
-                              valid-bound-ids?
-                              bound-id=?
-                              free-id=?
-                              with-transformer-environment
-                              transformer-environment
-                              resolve-identifier
-                              locally-bound-identifiers
-                              id-var-name
-                              same-marks?
-                              join-marks
-                              join-wraps
-                              smart-append
-                              make-binding-wrap
-                              extend-ribcage!
-                              make-empty-ribcage
-                              new-mark
-                              anti-mark
-                              the-anti-mark
-                              top-marked?
-                              top-wrap
-                              empty-wrap
-                              set-ribcage-labels!
-                              set-ribcage-marks!
-                              set-ribcage-symnames!
-                              ribcage-labels
-                              ribcage-marks
-                              ribcage-symnames
-                              ribcage?
-                              make-ribcage
-                              gen-labels
-                              gen-label
-                              make-rename
-                              rename-marks
-                              rename-new
-                              rename-old
-                              subst-rename?
-                              wrap-subst
-                              wrap-marks
-                              make-wrap
-                              id-sym-name&marks
-                              id-sym-name
-                              id?
-                              nonsymbol-id?
-                              global-extend
-                              lookup
-                              macros-only-env
-                              extend-var-env
-                              extend-env
-                              null-env
-                              binding-value
-                              binding-type
-                              make-binding
-                              arg-check
-                              source-annotation
-                              no-source
-                              set-syntax-object-module!
-                              set-syntax-object-wrap!
-                              set-syntax-object-expression!
-                              syntax-object-module
-                              syntax-object-wrap
-                              syntax-object-expression
-                              syntax-object?
-                              make-syntax-object
-                              build-lexical-var
-                              build-letrec
-                              build-named-let
-                              build-let
-                              build-sequence
-                              build-data
-                              build-primref
-                              build-lambda-case
-                              build-case-lambda
-                              build-simple-lambda
-                              build-global-definition
-                              build-global-assignment
-                              build-global-reference
-                              analyze-variable
-                              build-lexical-assignment
-                              build-lexical-reference
-                              build-dynlet
-                              build-conditional
-                              build-application
-                              build-void
-                              maybe-name-value!
-                              decorate-source
-                              get-global-definition-hook
-                              put-global-definition-hook
-                              session-id
-                              local-eval-hook
-                              top-level-eval-hook
-                              fx<
-                              fx=
-                              fx-
-                              fx+
-                              set-lambda-meta!
-                              lambda-meta
-                              lambda?
-                              make-dynlet
-                              make-letrec
-                              make-let
-                              make-lambda-case
-                              make-lambda
-                              make-sequence
-                              make-application
-                              make-conditional
-                              make-toplevel-define
-                              make-toplevel-set
-                              make-toplevel-ref
-                              make-module-set
-                              make-module-ref
-                              make-lexical-set
-                              make-lexical-ref
-                              make-primitive-ref
-                              make-const
-                              make-void)
-                            ((top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top)
-                             (top))
-                            ("l-*-476"
-                             "l-*-474"
-                             "l-*-472"
-                             "l-*-470"
-                             "l-*-468"
-                             "l-*-466"
-                             "l-*-464"
-                             "l-*-462"
-                             "l-*-460"
-                             "l-*-458"
-                             "l-*-456"
-                             "l-*-454"
-                             "l-*-452"
-                             "l-*-450"
-                             "l-*-448"
-                             "l-*-446"
-                             "l-*-444"
-                             "l-*-442"
-                             "l-*-440"
-                             "l-*-438"
-                             "l-*-436"
-                             "l-*-434"
-                             "l-*-432"
-                             "l-*-430"
-                             "l-*-428"
-                             "l-*-426"
-                             "l-*-424"
-                             "l-*-422"
-                             "l-*-420"
-                             "l-*-418"
-                             "l-*-416"
-                             "l-*-414"
-                             "l-*-412"
-                             "l-*-410"
-                             "l-*-408"
-                             "l-*-406"
-                             "l-*-404"
-                             "l-*-402"
-                             "l-*-400"
-                             "l-*-399"
-                             "l-*-397"
-                             "l-*-394"
-                             "l-*-393"
-                             "l-*-392"
-                             "l-*-390"
-                             "l-*-389"
-                             "l-*-387"
-                             "l-*-385"
-                             "l-*-383"
-                             "l-*-381"
-                             "l-*-379"
-                             "l-*-377"
-                             "l-*-375"
-                             "l-*-373"
-                             "l-*-370"
-                             "l-*-368"
-                             "l-*-367"
-                             "l-*-365"
-                             "l-*-363"
-                             "l-*-361"
-                             "l-*-359"
-                             "l-*-358"
-                             "l-*-357"
-                             "l-*-356"
-                             "l-*-354"
-                             "l-*-353"
-                             "l-*-350"
-                             "l-*-348"
-                             "l-*-346"
-                             "l-*-344"
-                             "l-*-342"
-                             "l-*-340"
-                             "l-*-338"
-                             "l-*-337"
-                             "l-*-336"
-                             "l-*-334"
-                             "l-*-332"
-                             "l-*-331"
-                             "l-*-328"
-                             "l-*-327"
-                             "l-*-325"
-                             "l-*-323"
-                             "l-*-321"
-                             "l-*-319"
-                             "l-*-317"
-                             "l-*-315"
-                             "l-*-313"
-                             "l-*-311"
-                             "l-*-309"
-                             "l-*-306"
-                             "l-*-304"
-                             "l-*-302"
-                             "l-*-300"
-                             "l-*-298"
-                             "l-*-296"
-                             "l-*-294"
-                             "l-*-292"
-                             "l-*-290"
-                             "l-*-288"
-                             "l-*-286"
-                             "l-*-284"
-                             "l-*-282"
-                             "l-*-280"
-                             "l-*-278"
-                             "l-*-276"
-                             "l-*-274"
-                             "l-*-272"
-                             "l-*-270"
-                             "l-*-268"
-                             "l-*-266"
-                             "l-*-264"
-                             "l-*-262"
-                             "l-*-260"
-                             "l-*-258"
-                             "l-*-256"
-                             "l-*-255"
-                             "l-*-254"
-                             "l-*-253"
-                             "l-*-252"
-                             "l-*-250"
-                             "l-*-248"
-                             "l-*-246"
-                             "l-*-243"
-                             "l-*-241"
-                             "l-*-239"
-                             "l-*-237"
-                             "l-*-235"
-                             "l-*-233"
-                             "l-*-231"
-                             "l-*-229"
-                             "l-*-227"
-                             "l-*-225"
-                             "l-*-223"
-                             "l-*-221"
-                             "l-*-219"
-                             "l-*-217"
-                             "l-*-215"
-                             "l-*-213"
-                             "l-*-211"
-                             "l-*-209"))
-                          #(ribcage
-                            (define-structure
-                              define-expansion-accessors
-                              define-expansion-constructors)
-                            ((top) (top) (top))
-                            ("l-*-47" "l-*-46" "l-*-45")))
-                         (hygiene guile))))
-             (eq? (id-var-name-4280 x-4941 '(()))
-                  (id-var-name-4280
-                    '#(syntax-object
-                       ...
-                       ((top)
-                        #(ribcage () () ())
-                        #(ribcage () () ())
-                        #(ribcage #(x) #((top)) #("l-*-2265"))
-                        #(ribcage
-                          (lambda-var-list
-                            gen-var
-                            strip
-                            expand-lambda-case
-                            lambda*-formals
-                            expand-simple-lambda
-                            lambda-formals
-                            ellipsis?
-                            expand-void
-                            eval-local-transformer
-                            expand-local-syntax
-                            expand-body
-                            expand-macro
-                            expand-application
-                            expand-expr
-                            expand
-                            syntax-type
-                            parse-when-list
-                            expand-install-global
-                            expand-top-sequence
-                            expand-sequence
-                            source-wrap
-                            wrap
-                            bound-id-member?
-                            distinct-bound-ids?
-                            valid-bound-ids?
-                            bound-id=?
-                            free-id=?
-                            with-transformer-environment
-                            transformer-environment
-                            resolve-identifier
-                            locally-bound-identifiers
-                            id-var-name
-                            same-marks?
-                            join-marks
-                            join-wraps
-                            smart-append
-                            make-binding-wrap
-                            extend-ribcage!
-                            make-empty-ribcage
-                            new-mark
-                            anti-mark
-                            the-anti-mark
-                            top-marked?
-                            top-wrap
-                            empty-wrap
-                            set-ribcage-labels!
-                            set-ribcage-marks!
-                            set-ribcage-symnames!
-                            ribcage-labels
-                            ribcage-marks
-                            ribcage-symnames
-                            ribcage?
-                            make-ribcage
-                            gen-labels
-                            gen-label
-                            make-rename
-                            rename-marks
-                            rename-new
-                            rename-old
-                            subst-rename?
-                            wrap-subst
-                            wrap-marks
-                            make-wrap
-                            id-sym-name&marks
-                            id-sym-name
-                            id?
-                            nonsymbol-id?
-                            global-extend
-                            lookup
-                            macros-only-env
-                            extend-var-env
-                            extend-env
-                            null-env
-                            binding-value
-                            binding-type
-                            make-binding
-                            arg-check
-                            source-annotation
-                            no-source
-                            set-syntax-object-module!
-                            set-syntax-object-wrap!
-                            set-syntax-object-expression!
-                            syntax-object-module
-                            syntax-object-wrap
-                            syntax-object-expression
-                            syntax-object?
-                            make-syntax-object
-                            build-lexical-var
-                            build-letrec
-                            build-named-let
-                            build-let
-                            build-sequence
-                            build-data
-                            build-primref
-                            build-lambda-case
-                            build-case-lambda
-                            build-simple-lambda
-                            build-global-definition
-                            build-global-assignment
-                            build-global-reference
-                            analyze-variable
-                            build-lexical-assignment
-                            build-lexical-reference
-                            build-dynlet
-                            build-conditional
-                            build-application
-                            build-void
-                            maybe-name-value!
-                            decorate-source
-                            get-global-definition-hook
-                            put-global-definition-hook
-                            session-id
-                            local-eval-hook
-                            top-level-eval-hook
-                            fx<
-                            fx=
-                            fx-
-                            fx+
-                            set-lambda-meta!
-                            lambda-meta
-                            lambda?
-                            make-dynlet
-                            make-letrec
-                            make-let
-                            make-lambda-case
-                            make-lambda
-                            make-sequence
-                            make-application
-                            make-conditional
-                            make-toplevel-define
-                            make-toplevel-set
-                            make-toplevel-ref
-                            make-module-set
-                            make-module-ref
-                            make-lexical-set
-                            make-lexical-ref
-                            make-primitive-ref
-                            make-const
-                            make-void)
-                          ((top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top)
-                           (top))
-                          ("l-*-476"
-                           "l-*-474"
-                           "l-*-472"
-                           "l-*-470"
-                           "l-*-468"
-                           "l-*-466"
-                           "l-*-464"
-                           "l-*-462"
-                           "l-*-460"
-                           "l-*-458"
-                           "l-*-456"
-                           "l-*-454"
-                           "l-*-452"
-                           "l-*-450"
-                           "l-*-448"
-                           "l-*-446"
-                           "l-*-444"
-                           "l-*-442"
-                           "l-*-440"
-                           "l-*-438"
-                           "l-*-436"
-                           "l-*-434"
-                           "l-*-432"
-                           "l-*-430"
-                           "l-*-428"
-                           "l-*-426"
-                           "l-*-424"
-                           "l-*-422"
-                           "l-*-420"
-                           "l-*-418"
-                           "l-*-416"
-                           "l-*-414"
-                           "l-*-412"
-                           "l-*-410"
-                           "l-*-408"
-                           "l-*-406"
-                           "l-*-404"
-                           "l-*-402"
-                           "l-*-400"
-                           "l-*-399"
-                           "l-*-397"
-                           "l-*-394"
-                           "l-*-393"
-                           "l-*-392"
-                           "l-*-390"
-                           "l-*-389"
-                           "l-*-387"
-                           "l-*-385"
-                           "l-*-383"
-                           "l-*-381"
-                           "l-*-379"
-                           "l-*-377"
-                           "l-*-375"
-                           "l-*-373"
-                           "l-*-370"
-                           "l-*-368"
-                           "l-*-367"
-                           "l-*-365"
-                           "l-*-363"
-                           "l-*-361"
-                           "l-*-359"
-                           "l-*-358"
-                           "l-*-357"
-                           "l-*-356"
-                           "l-*-354"
-                           "l-*-353"
-                           "l-*-350"
-                           "l-*-348"
-                           "l-*-346"
-                           "l-*-344"
-                           "l-*-342"
-                           "l-*-340"
-                           "l-*-338"
-                           "l-*-337"
-                           "l-*-336"
-                           "l-*-334"
-                           "l-*-332"
-                           "l-*-331"
-                           "l-*-328"
-                           "l-*-327"
-                           "l-*-325"
-                           "l-*-323"
-                           "l-*-321"
-                           "l-*-319"
-                           "l-*-317"
-                           "l-*-315"
-                           "l-*-313"
-                           "l-*-311"
-                           "l-*-309"
-                           "l-*-306"
-                           "l-*-304"
-                           "l-*-302"
-                           "l-*-300"
-                           "l-*-298"
-                           "l-*-296"
-                           "l-*-294"
-                           "l-*-292"
-                           "l-*-290"
-                           "l-*-288"
-                           "l-*-286"
-                           "l-*-284"
-                           "l-*-282"
-                           "l-*-280"
-                           "l-*-278"
-                           "l-*-276"
-                           "l-*-274"
-                           "l-*-272"
-                           "l-*-270"
-                           "l-*-268"
-                           "l-*-266"
-                           "l-*-264"
-                           "l-*-262"
-                           "l-*-260"
-                           "l-*-258"
-                           "l-*-256"
-                           "l-*-255"
-                           "l-*-254"
-                           "l-*-253"
-                           "l-*-252"
-                           "l-*-250"
-                           "l-*-248"
-                           "l-*-246"
-                           "l-*-243"
-                           "l-*-241"
-                           "l-*-239"
-                           "l-*-237"
-                           "l-*-235"
-                           "l-*-233"
-                           "l-*-231"
-                           "l-*-229"
-                           "l-*-227"
-                           "l-*-225"
-                           "l-*-223"
-                           "l-*-221"
-                           "l-*-219"
-                           "l-*-217"
-                           "l-*-215"
-                           "l-*-213"
-                           "l-*-211"
-                           "l-*-209"))
-                        #(ribcage
-                          (define-structure
-                            define-expansion-accessors
-                            define-expansion-constructors)
-                          ((top) (top) (top))
-                          ("l-*-47" "l-*-46" "l-*-45")))
-                       (hygiene guile))
-                    '(())))
-             #f)
-           #f)))
-     (lambda-formals-4306
-       (lambda (orig-args-22023)
-         (letrec*
-           ((req-22024
-              (lambda (args-22028 rreq-22029)
-                (let ((tmp-22031 ($sc-dispatch args-22028 '())))
-                  (if tmp-22031
-                    (@apply
-                      (lambda () (check-22025 (reverse rreq-22029) #f))
-                      tmp-22031)
-                    (let ((tmp-22154
-                            ($sc-dispatch args-22028 '(any . any))))
-                      (if (if tmp-22154
-                            (@apply
-                              (lambda (a-22158 b-22159)
-                                (if (symbol? a-22158)
-                                  #t
-                                  (if (if (vector? a-22158)
-                                        (if (= (vector-length a-22158) 4)
-                                          (eq? (vector-ref a-22158 0)
-                                               'syntax-object)
-                                          #f)
-                                        #f)
-                                    (symbol? (vector-ref a-22158 1))
-                                    #f)))
-                              tmp-22154)
-                            #f)
-                        (@apply
-                          (lambda (a-22186 b-22187)
-                            (req-22024 b-22187 (cons a-22186 rreq-22029)))
-                          tmp-22154)
-                        (let ((tmp-22188 (list args-22028)))
-                          (if (@apply
-                                (lambda (r-22190)
-                                  (if (symbol? r-22190)
-                                    #t
-                                    (if (if (vector? r-22190)
-                                          (if (= (vector-length r-22190) 4)
-                                            (eq? (vector-ref r-22190 0)
-                                                 'syntax-object)
-                                            #f)
-                                          #f)
-                                      (symbol? (vector-ref r-22190 1))
-                                      #f)))
-                                tmp-22188)
-                            (@apply
-                              (lambda (r-22220)
-                                (check-22025 (reverse rreq-22029) r-22220))
-                              tmp-22188)
-                            (syntax-violation
-                              'lambda
-                              "invalid argument list"
-                              orig-args-22023
-                              args-22028)))))))))
-            (check-22025
-              (lambda (req-22351 rest-22352)
-                (if (distinct-bound-ids?-4288
-                      (if rest-22352
-                        (cons rest-22352 req-22351)
-                        req-22351))
-                  (values req-22351 #f rest-22352 #f)
-                  (syntax-violation
-                    'lambda
-                    "duplicate identifier in argument list"
-                    orig-args-22023)))))
-           (req-22024 orig-args-22023 '()))))
-     (expand-simple-lambda-4307
-       (lambda (e-22468
-                r-22469
-                w-22470
-                s-22471
-                mod-22472
-                req-22473
-                rest-22474
-                meta-22475
-                body-22476)
-         (let ((ids-22477
-                 (if rest-22474
-                   (append req-22473 (list rest-22474))
-                   req-22473)))
-           (let ((vars-22478 (map gen-var-4311 ids-22477)))
-             (let ((labels-22479 (gen-labels-4264 ids-22477)))
-               (build-simple-lambda-4237
-                 s-22471
-                 (map syntax->datum req-22473)
-                 (if rest-22474 (syntax->datum rest-22474) #f)
-                 vars-22478
-                 meta-22475
-                 (expand-body-4301
-                   body-22476
-                   (wrap-4290
-                     (begin
-                       (if (if s-22471
-                             (supports-source-properties? e-22468)
-                             #f)
-                         (set-source-properties! e-22468 s-22471))
-                       e-22468)
-                     w-22470
-                     mod-22472)
-                   (extend-var-env-4256
-                     labels-22479
-                     vars-22478
-                     r-22469)
-                   (make-binding-wrap-4275
-                     ids-22477
-                     labels-22479
-                     w-22470)
-                   mod-22472)))))))
-     (lambda*-formals-4308
-       (lambda (orig-args-22759)
-         (letrec*
-           ((req-22760
-              (lambda (args-22767 rreq-22768)
-                (let ((tmp-22770 ($sc-dispatch args-22767 '())))
-                  (if tmp-22770
-                    (@apply
-                      (lambda ()
-                        (check-22764 (reverse rreq-22768) '() #f '()))
-                      tmp-22770)
-                    (let ((tmp-22776
-                            ($sc-dispatch args-22767 '(any . any))))
-                      (if (if tmp-22776
-                            (@apply
-                              (lambda (a-22780 b-22781)
-                                (if (symbol? a-22780)
-                                  #t
-                                  (if (if (vector? a-22780)
-                                        (if (= (vector-length a-22780) 4)
-                                          (eq? (vector-ref a-22780 0)
-                                               'syntax-object)
-                                          #f)
-                                        #f)
-                                    (symbol? (vector-ref a-22780 1))
-                                    #f)))
-                              tmp-22776)
-                            #f)
-                        (@apply
-                          (lambda (a-22808 b-22809)
-                            (req-22760 b-22809 (cons a-22808 rreq-22768)))
-                          tmp-22776)
-                        (let ((tmp-22810
-                                ($sc-dispatch args-22767 '(any . any))))
-                          (if (if tmp-22810
-                                (@apply
-                                  (lambda (a-22814 b-22815)
-                                    (eq? (syntax->datum a-22814) #:optional))
-                                  tmp-22810)
-                                #f)
-                            (@apply
-                              (lambda (a-22816 b-22817)
-                                (opt-22761 b-22817 (reverse rreq-22768) '()))
-                              tmp-22810)
-                            (let ((tmp-22820
-                                    ($sc-dispatch args-22767 '(any . any))))
-                              (if (if tmp-22820
-                                    (@apply
-                                      (lambda (a-22824 b-22825)
-                                        (eq? (syntax->datum a-22824) #:key))
-                                      tmp-22820)
-                                    #f)
-                                (@apply
-                                  (lambda (a-22826 b-22827)
-                                    (key-22762
-                                      b-22827
-                                      (reverse rreq-22768)
-                                      '()
-                                      '()))
-                                  tmp-22820)
-                                (let ((tmp-22830
-                                        ($sc-dispatch args-22767 '(any any))))
-                                  (if (if tmp-22830
-                                        (@apply
-                                          (lambda (a-22834 b-22835)
-                                            (eq? (syntax->datum a-22834)
-                                                 #:rest))
-                                          tmp-22830)
-                                        #f)
-                                    (@apply
-                                      (lambda (a-22836 b-22837)
-                                        (rest-22763
-                                          b-22837
-                                          (reverse rreq-22768)
-                                          '()
-                                          '()))
-                                      tmp-22830)
-                                    (let ((tmp-22840 (list args-22767)))
-                                      (if (@apply
-                                            (lambda (r-22842)
-                                              (if (symbol? r-22842)
-                                                #t
-                                                (if (if (vector? r-22842)
-                                                      (if (= (vector-length
-                                                               r-22842)
-                                                             4)
-                                                        (eq? (vector-ref
-                                                               r-22842
-                                                               0)
-                                                             'syntax-object)
-                                                        #f)
-                                                      #f)
-                                                  (symbol?
-                                                    (vector-ref r-22842 1))
-                                                  #f)))
-                                            tmp-22840)
-                                        (@apply
-                                          (lambda (r-22872)
-                                            (rest-22763
-                                              r-22872
-                                              (reverse rreq-22768)
-                                              '()
-                                              '()))
-                                          tmp-22840)
-                                        (syntax-violation
-                                          'lambda*
-                                          "invalid argument list"
-                                          orig-args-22759
-                                          args-22767)))))))))))))))
-            (opt-22761
-              (lambda (args-22891 req-22892 ropt-22893)
-                (let ((tmp-22895 ($sc-dispatch args-22891 '())))
-                  (if tmp-22895
-                    (@apply
-                      (lambda ()
-                        (check-22764
-                          req-22892
-                          (reverse ropt-22893)
-                          #f
-                          '()))
-                      tmp-22895)
-                    (let ((tmp-22901
-                            ($sc-dispatch args-22891 '(any . any))))
-                      (if (if tmp-22901
-                            (@apply
-                              (lambda (a-22905 b-22906)
-                                (if (symbol? a-22905)
-                                  #t
-                                  (if (if (vector? a-22905)
-                                        (if (= (vector-length a-22905) 4)
-                                          (eq? (vector-ref a-22905 0)
-                                               'syntax-object)
-                                          #f)
-                                        #f)
-                                    (symbol? (vector-ref a-22905 1))
-                                    #f)))
-                              tmp-22901)
-                            #f)
-                        (@apply
-                          (lambda (a-22933 b-22934)
-                            (opt-22761
-                              b-22934
-                              req-22892
-                              (cons (cons a-22933
-                                          '(#(syntax-object
-                                              #f
-                                              ((top)
-                                               #(ribcage
-                                                 #(a b)
-                                                 #((top) (top))
-                                                 #("l-*-2402" "l-*-2403"))
-                                               #(ribcage () () ())
-                                               #(ribcage
-                                                 #(args req ropt)
-                                                 #((top) (top) (top))
-                                                 #("l-*-2392"
-                                                   "l-*-2393"
-                                                   "l-*-2394"))
-                                               #(ribcage
-                                                 (check rest key opt req)
-                                                 ((top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top))
-                                                 ("l-*-2338"
-                                                  "l-*-2336"
-                                                  "l-*-2334"
-                                                  "l-*-2332"
-                                                  "l-*-2330"))
-                                               #(ribcage
-                                                 #(orig-args)
-                                                 #((top))
-                                                 #("l-*-2329"))
-                                               #(ribcage
-                                                 (lambda-var-list
-                                                   gen-var
-                                                   strip
-                                                   expand-lambda-case
-                                                   lambda*-formals
-                                                   expand-simple-lambda
-                                                   lambda-formals
-                                                   ellipsis?
-                                                   expand-void
-                                                   eval-local-transformer
-                                                   expand-local-syntax
-                                                   expand-body
-                                                   expand-macro
-                                                   expand-application
-                                                   expand-expr
-                                                   expand
-                                                   syntax-type
-                                                   parse-when-list
-                                                   expand-install-global
-                                                   expand-top-sequence
-                                                   expand-sequence
-                                                   source-wrap
-                                                   wrap
-                                                   bound-id-member?
-                                                   distinct-bound-ids?
-                                                   valid-bound-ids?
-                                                   bound-id=?
-                                                   free-id=?
-                                                   with-transformer-environment
-                                                   transformer-environment
-                                                   resolve-identifier
-                                                   locally-bound-identifiers
-                                                   id-var-name
-                                                   same-marks?
-                                                   join-marks
-                                                   join-wraps
-                                                   smart-append
-                                                   make-binding-wrap
-                                                   extend-ribcage!
-                                                   make-empty-ribcage
-                                                   new-mark
-                                                   anti-mark
-                                                   the-anti-mark
-                                                   top-marked?
-                                                   top-wrap
-                                                   empty-wrap
-                                                   set-ribcage-labels!
-                                                   set-ribcage-marks!
-                                                   set-ribcage-symnames!
-                                                   ribcage-labels
-                                                   ribcage-marks
-                                                   ribcage-symnames
-                                                   ribcage?
-                                                   make-ribcage
-                                                   gen-labels
-                                                   gen-label
-                                                   make-rename
-                                                   rename-marks
-                                                   rename-new
-                                                   rename-old
-                                                   subst-rename?
-                                                   wrap-subst
-                                                   wrap-marks
-                                                   make-wrap
-                                                   id-sym-name&marks
-                                                   id-sym-name
-                                                   id?
-                                                   nonsymbol-id?
-                                                   global-extend
-                                                   lookup
-                                                   macros-only-env
-                                                   extend-var-env
-                                                   extend-env
-                                                   null-env
-                                                   binding-value
-                                                   binding-type
-                                                   make-binding
-                                                   arg-check
-                                                   source-annotation
-                                                   no-source
-                                                   set-syntax-object-module!
-                                                   set-syntax-object-wrap!
-                                                   
set-syntax-object-expression!
-                                                   syntax-object-module
-                                                   syntax-object-wrap
-                                                   syntax-object-expression
-                                                   syntax-object?
-                                                   make-syntax-object
-                                                   build-lexical-var
-                                                   build-letrec
-                                                   build-named-let
-                                                   build-let
-                                                   build-sequence
-                                                   build-data
-                                                   build-primref
-                                                   build-lambda-case
-                                                   build-case-lambda
-                                                   build-simple-lambda
-                                                   build-global-definition
-                                                   build-global-assignment
-                                                   build-global-reference
-                                                   analyze-variable
-                                                   build-lexical-assignment
-                                                   build-lexical-reference
-                                                   build-dynlet
-                                                   build-conditional
-                                                   build-application
-                                                   build-void
-                                                   maybe-name-value!
-                                                   decorate-source
-                                                   get-global-definition-hook
-                                                   put-global-definition-hook
-                                                   session-id
-                                                   local-eval-hook
-                                                   top-level-eval-hook
-                                                   fx<
-                                                   fx=
-                                                   fx-
-                                                   fx+
-                                                   set-lambda-meta!
-                                                   lambda-meta
-                                                   lambda?
-                                                   make-dynlet
-                                                   make-letrec
-                                                   make-let
-                                                   make-lambda-case
-                                                   make-lambda
-                                                   make-sequence
-                                                   make-application
-                                                   make-conditional
-                                                   make-toplevel-define
-                                                   make-toplevel-set
-                                                   make-toplevel-ref
-                                                   make-module-set
-                                                   make-module-ref
-                                                   make-lexical-set
-                                                   make-lexical-ref
-                                                   make-primitive-ref
-                                                   make-const
-                                                   make-void)
-                                                 ((top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top)
-                                                  (top))
-                                                 ("l-*-476"
-                                                  "l-*-474"
-                                                  "l-*-472"
-                                                  "l-*-470"
-                                                  "l-*-468"
-                                                  "l-*-466"
-                                                  "l-*-464"
-                                                  "l-*-462"
-                                                  "l-*-460"
-                                                  "l-*-458"
-                                                  "l-*-456"
-                                                  "l-*-454"
-                                                  "l-*-452"
-                                                  "l-*-450"
-                                                  "l-*-448"
-                                                  "l-*-446"
-                                                  "l-*-444"
-                                                  "l-*-442"
-                                                  "l-*-440"
-                                                  "l-*-438"
-                                                  "l-*-436"
-                                                  "l-*-434"
-                                                  "l-*-432"
-                                                  "l-*-430"
-                                                  "l-*-428"
-                                                  "l-*-426"
-                                                  "l-*-424"
-                                                  "l-*-422"
-                                                  "l-*-420"
-                                                  "l-*-418"
-                                                  "l-*-416"
-                                                  "l-*-414"
-                                                  "l-*-412"
-                                                  "l-*-410"
-                                                  "l-*-408"
-                                                  "l-*-406"
-                                                  "l-*-404"
-                                                  "l-*-402"
-                                                  "l-*-400"
-                                                  "l-*-399"
-                                                  "l-*-397"
-                                                  "l-*-394"
-                                                  "l-*-393"
-                                                  "l-*-392"
-                                                  "l-*-390"
-                                                  "l-*-389"
-                                                  "l-*-387"
-                                                  "l-*-385"
-                                                  "l-*-383"
-                                                  "l-*-381"
-                                                  "l-*-379"
-                                                  "l-*-377"
-                                                  "l-*-375"
-                                                  "l-*-373"
-                                                  "l-*-370"
-                                                  "l-*-368"
-                                                  "l-*-367"
-                                                  "l-*-365"
-                                                  "l-*-363"
-                                                  "l-*-361"
-                                                  "l-*-359"
-                                                  "l-*-358"
-                                                  "l-*-357"
-                                                  "l-*-356"
-                                                  "l-*-354"
-                                                  "l-*-353"
-                                                  "l-*-350"
-                                                  "l-*-348"
-                                                  "l-*-346"
-                                                  "l-*-344"
-                                                  "l-*-342"
-                                                  "l-*-340"
-                                                  "l-*-338"
-                                                  "l-*-337"
-                                                  "l-*-336"
-                                                  "l-*-334"
-                                                  "l-*-332"
-                                                  "l-*-331"
-                                                  "l-*-328"
-                                                  "l-*-327"
-                                                  "l-*-325"
-                                                  "l-*-323"
-                                                  "l-*-321"
-                                                  "l-*-319"
-                                                  "l-*-317"
-                                                  "l-*-315"
-                                                  "l-*-313"
-                                                  "l-*-311"
-                                                  "l-*-309"
-                                                  "l-*-306"
-                                                  "l-*-304"
-                                                  "l-*-302"
-                                                  "l-*-300"
-                                                  "l-*-298"
-                                                  "l-*-296"
-                                                  "l-*-294"
-                                                  "l-*-292"
-                                                  "l-*-290"
-                                                  "l-*-288"
-                                                  "l-*-286"
-                                                  "l-*-284"
-                                                  "l-*-282"
-                                                  "l-*-280"
-                                                  "l-*-278"
-                                                  "l-*-276"
-                                                  "l-*-274"
-                                                  "l-*-272"
-                                                  "l-*-270"
-                                                  "l-*-268"
-                                                  "l-*-266"
-                                                  "l-*-264"
-                                                  "l-*-262"
-                                                  "l-*-260"
-                                                  "l-*-258"
-                                                  "l-*-256"
-                                                  "l-*-255"
-                                                  "l-*-254"
-                                                  "l-*-253"
-                                                  "l-*-252"
-                                                  "l-*-250"
-                                                  "l-*-248"
-                                                  "l-*-246"
-                                                  "l-*-243"
-                                                  "l-*-241"
-                                                  "l-*-239"
-                                                  "l-*-237"
-                                                  "l-*-235"
-                                                  "l-*-233"
-                                                  "l-*-231"
-                                                  "l-*-229"
-                                                  "l-*-227"
-                                                  "l-*-225"
-                                                  "l-*-223"
-                                                  "l-*-221"
-                                                  "l-*-219"
-                                                  "l-*-217"
-                                                  "l-*-215"
-                                                  "l-*-213"
-                                                  "l-*-211"
-                                                  "l-*-209"))
-                                               #(ribcage
-                                                 (define-structure
-                                                   define-expansion-accessors
-                                                   
define-expansion-constructors)
-                                                 ((top) (top) (top))
-                                                 ("l-*-47" "l-*-46" "l-*-45")))
-                                              (hygiene guile))))
-                                    ropt-22893)))
-                          tmp-22901)
-                        (let ((tmp-22935
-                                ($sc-dispatch args-22891 '((any any) . any))))
-                          (if (if tmp-22935
-                                (@apply
-                                  (lambda (a-22939 init-22940 b-22941)
-                                    (if (symbol? a-22939)
-                                      #t
-                                      (if (if (vector? a-22939)
-                                            (if (= (vector-length a-22939) 4)
-                                              (eq? (vector-ref a-22939 0)
-                                                   'syntax-object)
-                                              #f)
-                                            #f)
-                                        (symbol? (vector-ref a-22939 1))
-                                        #f)))
-                                  tmp-22935)
-                                #f)
-                            (@apply
-                              (lambda (a-22968 init-22969 b-22970)
-                                (opt-22761
-                                  b-22970
-                                  req-22892
-                                  (cons (list a-22968 init-22969) ropt-22893)))
-                              tmp-22935)
-                            (let ((tmp-22971
-                                    ($sc-dispatch args-22891 '(any . any))))
-                              (if (if tmp-22971
-                                    (@apply
-                                      (lambda (a-22975 b-22976)
-                                        (eq? (syntax->datum a-22975) #:key))
-                                      tmp-22971)
-                                    #f)
-                                (@apply
-                                  (lambda (a-22977 b-22978)
-                                    (key-22762
-                                      b-22978
-                                      req-22892
-                                      (reverse ropt-22893)
-                                      '()))
-                                  tmp-22971)
-                                (let ((tmp-22981
-                                        ($sc-dispatch args-22891 '(any any))))
-                                  (if (if tmp-22981
-                                        (@apply
-                                          (lambda (a-22985 b-22986)
-                                            (eq? (syntax->datum a-22985)
-                                                 #:rest))
-                                          tmp-22981)
-                                        #f)
-                                    (@apply
-                                      (lambda (a-22987 b-22988)
-                                        (rest-22763
-                                          b-22988
-                                          req-22892
-                                          (reverse ropt-22893)
-                                          '()))
-                                      tmp-22981)
-                                    (let ((tmp-22991 (list args-22891)))
-                                      (if (@apply
-                                            (lambda (r-22993)
-                                              (if (symbol? r-22993)
-                                                #t
-                                                (if (if (vector? r-22993)
-                                                      (if (= (vector-length
-                                                               r-22993)
-                                                             4)
-                                                        (eq? (vector-ref
-                                                               r-22993
-                                                               0)
-                                                             'syntax-object)
-                                                        #f)
-                                                      #f)
-                                                  (symbol?
-                                                    (vector-ref r-22993 1))
-                                                  #f)))
-                                            tmp-22991)
-                                        (@apply
-                                          (lambda (r-23023)
-                                            (rest-22763
-                                              r-23023
-                                              req-22892
-                                              (reverse ropt-22893)
-                                              '()))
-                                          tmp-22991)
-                                        (syntax-violation
-                                          'lambda*
-                                          "invalid optional argument list"
-                                          orig-args-22759
-                                          args-22891)))))))))))))))
-            (key-22762
-              (lambda (args-23042 req-23043 opt-23044 rkey-23045)
-                (let ((tmp-23047 ($sc-dispatch args-23042 '())))
-                  (if tmp-23047
-                    (@apply
-                      (lambda ()
-                        (check-22764
-                          req-23043
-                          opt-23044
-                          #f
-                          (cons #f (reverse rkey-23045))))
-                      tmp-23047)
-                    (let ((tmp-23053
-                            ($sc-dispatch args-23042 '(any . any))))
-                      (if (if tmp-23053
-                            (@apply
-                              (lambda (a-23057 b-23058)
-                                (if (symbol? a-23057)
-                                  #t
-                                  (if (if (vector? a-23057)
-                                        (if (= (vector-length a-23057) 4)
-                                          (eq? (vector-ref a-23057 0)
-                                               'syntax-object)
-                                          #f)
-                                        #f)
-                                    (symbol? (vector-ref a-23057 1))
-                                    #f)))
-                              tmp-23053)
-                            #f)
-                        (@apply
-                          (lambda (a-23085 b-23086)
-                            (let ((tmp-23087
-                                    (symbol->keyword (syntax->datum a-23085))))
-                              (key-22762
-                                b-23086
-                                req-23043
-                                opt-23044
-                                (cons (cons tmp-23087
-                                            (cons a-23085
-                                                  '(#(syntax-object
-                                                      #f
-                                                      ((top)
-                                                       #(ribcage () () ())
-                                                       #(ribcage
-                                                         #(k)
-                                                         #((top))
-                                                         #("l-*-2465"))
-                                                       #(ribcage
-                                                         #(a b)
-                                                         #((top) (top))
-                                                         #("l-*-2459"
-                                                           "l-*-2460"))
-                                                       #(ribcage () () ())
-                                                       #(ribcage
-                                                         #(args req opt rkey)
-                                                         #((top)
-                                                           (top)
-                                                           (top)
-                                                           (top))
-                                                         #("l-*-2448"
-                                                           "l-*-2449"
-                                                           "l-*-2450"
-                                                           "l-*-2451"))
-                                                       #(ribcage
-                                                         (check rest
-                                                                key
-                                                                opt
-                                                                req)
-                                                         ((top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top))
-                                                         ("l-*-2338"
-                                                          "l-*-2336"
-                                                          "l-*-2334"
-                                                          "l-*-2332"
-                                                          "l-*-2330"))
-                                                       #(ribcage
-                                                         #(orig-args)
-                                                         #((top))
-                                                         #("l-*-2329"))
-                                                       #(ribcage
-                                                         (lambda-var-list
-                                                           gen-var
-                                                           strip
-                                                           expand-lambda-case
-                                                           lambda*-formals
-                                                           expand-simple-lambda
-                                                           lambda-formals
-                                                           ellipsis?
-                                                           expand-void
-                                                           
eval-local-transformer
-                                                           expand-local-syntax
-                                                           expand-body
-                                                           expand-macro
-                                                           expand-application
-                                                           expand-expr
-                                                           expand
-                                                           syntax-type
-                                                           parse-when-list
-                                                           
expand-install-global
-                                                           expand-top-sequence
-                                                           expand-sequence
-                                                           source-wrap
-                                                           wrap
-                                                           bound-id-member?
-                                                           distinct-bound-ids?
-                                                           valid-bound-ids?
-                                                           bound-id=?
-                                                           free-id=?
-                                                           
with-transformer-environment
-                                                           
transformer-environment
-                                                           resolve-identifier
-                                                           
locally-bound-identifiers
-                                                           id-var-name
-                                                           same-marks?
-                                                           join-marks
-                                                           join-wraps
-                                                           smart-append
-                                                           make-binding-wrap
-                                                           extend-ribcage!
-                                                           make-empty-ribcage
-                                                           new-mark
-                                                           anti-mark
-                                                           the-anti-mark
-                                                           top-marked?
-                                                           top-wrap
-                                                           empty-wrap
-                                                           set-ribcage-labels!
-                                                           set-ribcage-marks!
-                                                           
set-ribcage-symnames!
-                                                           ribcage-labels
-                                                           ribcage-marks
-                                                           ribcage-symnames
-                                                           ribcage?
-                                                           make-ribcage
-                                                           gen-labels
-                                                           gen-label
-                                                           make-rename
-                                                           rename-marks
-                                                           rename-new
-                                                           rename-old
-                                                           subst-rename?
-                                                           wrap-subst
-                                                           wrap-marks
-                                                           make-wrap
-                                                           id-sym-name&marks
-                                                           id-sym-name
-                                                           id?
-                                                           nonsymbol-id?
-                                                           global-extend
-                                                           lookup
-                                                           macros-only-env
-                                                           extend-var-env
-                                                           extend-env
-                                                           null-env
-                                                           binding-value
-                                                           binding-type
-                                                           make-binding
-                                                           arg-check
-                                                           source-annotation
-                                                           no-source
-                                                           
set-syntax-object-module!
-                                                           
set-syntax-object-wrap!
-                                                           
set-syntax-object-expression!
-                                                           syntax-object-module
-                                                           syntax-object-wrap
-                                                           
syntax-object-expression
-                                                           syntax-object?
-                                                           make-syntax-object
-                                                           build-lexical-var
-                                                           build-letrec
-                                                           build-named-let
-                                                           build-let
-                                                           build-sequence
-                                                           build-data
-                                                           build-primref
-                                                           build-lambda-case
-                                                           build-case-lambda
-                                                           build-simple-lambda
-                                                           
build-global-definition
-                                                           
build-global-assignment
-                                                           
build-global-reference
-                                                           analyze-variable
-                                                           
build-lexical-assignment
-                                                           
build-lexical-reference
-                                                           build-dynlet
-                                                           build-conditional
-                                                           build-application
-                                                           build-void
-                                                           maybe-name-value!
-                                                           decorate-source
-                                                           
get-global-definition-hook
-                                                           
put-global-definition-hook
-                                                           session-id
-                                                           local-eval-hook
-                                                           top-level-eval-hook
-                                                           fx<
-                                                           fx=
-                                                           fx-
-                                                           fx+
-                                                           set-lambda-meta!
-                                                           lambda-meta
-                                                           lambda?
-                                                           make-dynlet
-                                                           make-letrec
-                                                           make-let
-                                                           make-lambda-case
-                                                           make-lambda
-                                                           make-sequence
-                                                           make-application
-                                                           make-conditional
-                                                           make-toplevel-define
-                                                           make-toplevel-set
-                                                           make-toplevel-ref
-                                                           make-module-set
-                                                           make-module-ref
-                                                           make-lexical-set
-                                                           make-lexical-ref
-                                                           make-primitive-ref
-                                                           make-const
-                                                           make-void)
-                                                         ((top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top))
-                                                         ("l-*-476"
-                                                          "l-*-474"
-                                                          "l-*-472"
-                                                          "l-*-470"
-                                                          "l-*-468"
-                                                          "l-*-466"
-                                                          "l-*-464"
-                                                          "l-*-462"
-                                                          "l-*-460"
-                                                          "l-*-458"
-                                                          "l-*-456"
-                                                          "l-*-454"
-                                                          "l-*-452"
-                                                          "l-*-450"
-                                                          "l-*-448"
-                                                          "l-*-446"
-                                                          "l-*-444"
-                                                          "l-*-442"
-                                                          "l-*-440"
-                                                          "l-*-438"
-                                                          "l-*-436"
-                                                          "l-*-434"
-                                                          "l-*-432"
-                                                          "l-*-430"
-                                                          "l-*-428"
-                                                          "l-*-426"
-                                                          "l-*-424"
-                                                          "l-*-422"
-                                                          "l-*-420"
-                                                          "l-*-418"
-                                                          "l-*-416"
-                                                          "l-*-414"
-                                                          "l-*-412"
-                                                          "l-*-410"
-                                                          "l-*-408"
-                                                          "l-*-406"
-                                                          "l-*-404"
-                                                          "l-*-402"
-                                                          "l-*-400"
-                                                          "l-*-399"
-                                                          "l-*-397"
-                                                          "l-*-394"
-                                                          "l-*-393"
-                                                          "l-*-392"
-                                                          "l-*-390"
-                                                          "l-*-389"
-                                                          "l-*-387"
-                                                          "l-*-385"
-                                                          "l-*-383"
-                                                          "l-*-381"
-                                                          "l-*-379"
-                                                          "l-*-377"
-                                                          "l-*-375"
-                                                          "l-*-373"
-                                                          "l-*-370"
-                                                          "l-*-368"
-                                                          "l-*-367"
-                                                          "l-*-365"
-                                                          "l-*-363"
-                                                          "l-*-361"
-                                                          "l-*-359"
-                                                          "l-*-358"
-                                                          "l-*-357"
-                                                          "l-*-356"
-                                                          "l-*-354"
-                                                          "l-*-353"
-                                                          "l-*-350"
-                                                          "l-*-348"
-                                                          "l-*-346"
-                                                          "l-*-344"
-                                                          "l-*-342"
-                                                          "l-*-340"
-                                                          "l-*-338"
-                                                          "l-*-337"
-                                                          "l-*-336"
-                                                          "l-*-334"
-                                                          "l-*-332"
-                                                          "l-*-331"
-                                                          "l-*-328"
-                                                          "l-*-327"
-                                                          "l-*-325"
-                                                          "l-*-323"
-                                                          "l-*-321"
-                                                          "l-*-319"
-                                                          "l-*-317"
-                                                          "l-*-315"
-                                                          "l-*-313"
-                                                          "l-*-311"
-                                                          "l-*-309"
-                                                          "l-*-306"
-                                                          "l-*-304"
-                                                          "l-*-302"
-                                                          "l-*-300"
-                                                          "l-*-298"
-                                                          "l-*-296"
-                                                          "l-*-294"
-                                                          "l-*-292"
-                                                          "l-*-290"
-                                                          "l-*-288"
-                                                          "l-*-286"
-                                                          "l-*-284"
-                                                          "l-*-282"
-                                                          "l-*-280"
-                                                          "l-*-278"
-                                                          "l-*-276"
-                                                          "l-*-274"
-                                                          "l-*-272"
-                                                          "l-*-270"
-                                                          "l-*-268"
-                                                          "l-*-266"
-                                                          "l-*-264"
-                                                          "l-*-262"
-                                                          "l-*-260"
-                                                          "l-*-258"
-                                                          "l-*-256"
-                                                          "l-*-255"
-                                                          "l-*-254"
-                                                          "l-*-253"
-                                                          "l-*-252"
-                                                          "l-*-250"
-                                                          "l-*-248"
-                                                          "l-*-246"
-                                                          "l-*-243"
-                                                          "l-*-241"
-                                                          "l-*-239"
-                                                          "l-*-237"
-                                                          "l-*-235"
-                                                          "l-*-233"
-                                                          "l-*-231"
-                                                          "l-*-229"
-                                                          "l-*-227"
-                                                          "l-*-225"
-                                                          "l-*-223"
-                                                          "l-*-221"
-                                                          "l-*-219"
-                                                          "l-*-217"
-                                                          "l-*-215"
-                                                          "l-*-213"
-                                                          "l-*-211"
-                                                          "l-*-209"))
-                                                       #(ribcage
-                                                         (define-structure
-                                                           
define-expansion-accessors
-                                                           
define-expansion-constructors)
-                                                         ((top) (top) (top))
-                                                         ("l-*-47"
-                                                          "l-*-46"
-                                                          "l-*-45")))
-                                                      (hygiene guile)))))
-                                      rkey-23045))))
-                          tmp-23053)
-                        (let ((tmp-23090
-                                ($sc-dispatch args-23042 '((any any) . any))))
-                          (if (if tmp-23090
-                                (@apply
-                                  (lambda (a-23094 init-23095 b-23096)
-                                    (if (symbol? a-23094)
-                                      #t
-                                      (if (if (vector? a-23094)
-                                            (if (= (vector-length a-23094) 4)
-                                              (eq? (vector-ref a-23094 0)
-                                                   'syntax-object)
-                                              #f)
-                                            #f)
-                                        (symbol? (vector-ref a-23094 1))
-                                        #f)))
-                                  tmp-23090)
-                                #f)
-                            (@apply
-                              (lambda (a-23123 init-23124 b-23125)
-                                (let ((tmp-23126
-                                        (symbol->keyword
-                                          (syntax->datum a-23123))))
-                                  (key-22762
-                                    b-23125
-                                    req-23043
-                                    opt-23044
-                                    (cons (list tmp-23126 a-23123 init-23124)
-                                          rkey-23045))))
-                              tmp-23090)
-                            (let ((tmp-23129
-                                    ($sc-dispatch
-                                      args-23042
-                                      '((any any any) . any))))
-                              (if (if tmp-23129
-                                    (@apply
-                                      (lambda (a-23133
-                                               init-23134
-                                               k-23135
-                                               b-23136)
-                                        (if (if (symbol? a-23133)
-                                              #t
-                                              (if (if (vector? a-23133)
-                                                    (if (= (vector-length
-                                                             a-23133)
-                                                           4)
-                                                      (eq? (vector-ref
-                                                             a-23133
-                                                             0)
-                                                           'syntax-object)
-                                                      #f)
-                                                    #f)
-                                                (symbol?
-                                                  (vector-ref a-23133 1))
-                                                #f))
-                                          (keyword? (syntax->datum k-23135))
-                                          #f))
-                                      tmp-23129)
-                                    #f)
-                                (@apply
-                                  (lambda (a-23163 init-23164 k-23165 b-23166)
-                                    (key-22762
-                                      b-23166
-                                      req-23043
-                                      opt-23044
-                                      (cons (list k-23165 a-23163 init-23164)
-                                            rkey-23045)))
-                                  tmp-23129)
-                                (let ((tmp-23167
-                                        ($sc-dispatch args-23042 '(any))))
-                                  (if (if tmp-23167
-                                        (@apply
-                                          (lambda (aok-23171)
-                                            (eq? (syntax->datum aok-23171)
-                                                 #:allow-other-keys))
-                                          tmp-23167)
-                                        #f)
-                                    (@apply
-                                      (lambda (aok-23172)
-                                        (check-22764
-                                          req-23043
-                                          opt-23044
-                                          #f
-                                          (cons #t (reverse rkey-23045))))
-                                      tmp-23167)
-                                    (let ((tmp-23175
-                                            ($sc-dispatch
-                                              args-23042
-                                              '(any any any))))
-                                      (if (if tmp-23175
-                                            (@apply
-                                              (lambda (aok-23179
-                                                       a-23180
-                                                       b-23181)
-                                                (if (eq? (syntax->datum
-                                                           aok-23179)
-                                                         #:allow-other-keys)
-                                                  (eq? (syntax->datum a-23180)
-                                                       #:rest)
-                                                  #f))
-                                              tmp-23175)
-                                            #f)
-                                        (@apply
-                                          (lambda (aok-23182 a-23183 b-23184)
-                                            (rest-22763
-                                              b-23184
-                                              req-23043
-                                              opt-23044
-                                              (cons #t (reverse rkey-23045))))
-                                          tmp-23175)
-                                        (let ((tmp-23187
-                                                ($sc-dispatch
-                                                  args-23042
-                                                  '(any . any))))
-                                          (if (if tmp-23187
-                                                (@apply
-                                                  (lambda (aok-23191 r-23192)
-                                                    (if (eq? (syntax->datum
-                                                               aok-23191)
-                                                             
#:allow-other-keys)
-                                                      (if (symbol? r-23192)
-                                                        #t
-                                                        (if (if (vector?
-                                                                  r-23192)
-                                                              (if (= 
(vector-length
-                                                                       r-23192)
-                                                                     4)
-                                                                (eq? 
(vector-ref
-                                                                       r-23192
-                                                                       0)
-                                                                     
'syntax-object)
-                                                                #f)
-                                                              #f)
-                                                          (symbol?
-                                                            (vector-ref
-                                                              r-23192
-                                                              1))
-                                                          #f))
-                                                      #f))
-                                                  tmp-23187)
-                                                #f)
-                                            (@apply
-                                              (lambda (aok-23219 r-23220)
-                                                (rest-22763
-                                                  r-23220
-                                                  req-23043
-                                                  opt-23044
-                                                  (cons #t
-                                                        (reverse rkey-23045))))
-                                              tmp-23187)
-                                            (let ((tmp-23223
-                                                    ($sc-dispatch
-                                                      args-23042
-                                                      '(any any))))
-                                              (if (if tmp-23223
-                                                    (@apply
-                                                      (lambda (a-23227 b-23228)
-                                                        (eq? (syntax->datum
-                                                               a-23227)
-                                                             #:rest))
-                                                      tmp-23223)
-                                                    #f)
-                                                (@apply
-                                                  (lambda (a-23229 b-23230)
-                                                    (rest-22763
-                                                      b-23230
-                                                      req-23043
-                                                      opt-23044
-                                                      (cons #f
-                                                            (reverse
-                                                              rkey-23045))))
-                                                  tmp-23223)
-                                                (let ((tmp-23233
-                                                        (list args-23042)))
-                                                  (if (@apply
-                                                        (lambda (r-23235)
-                                                          (if (symbol? r-23235)
-                                                            #t
-                                                            (if (if (vector?
-                                                                      r-23235)
-                                                                  (if (= 
(vector-length
-                                                                           
r-23235)
-                                                                         4)
-                                                                    (eq? 
(vector-ref
-                                                                           
r-23235
-                                                                           0)
-                                                                         
'syntax-object)
-                                                                    #f)
-                                                                  #f)
-                                                              (symbol?
-                                                                (vector-ref
-                                                                  r-23235
-                                                                  1))
-                                                              #f)))
-                                                        tmp-23233)
-                                                    (@apply
-                                                      (lambda (r-23265)
-                                                        (rest-22763
-                                                          r-23265
-                                                          req-23043
-                                                          opt-23044
-                                                          (cons #f
-                                                                (reverse
-                                                                  
rkey-23045))))
-                                                      tmp-23233)
-                                                    (syntax-violation
-                                                      'lambda*
-                                                      "invalid keyword 
argument list"
-                                                      orig-args-22759
-                                                      
args-23042)))))))))))))))))))))
-            (rest-22763
-              (lambda (args-23293 req-23294 opt-23295 kw-23296)
-                (let ((tmp-23298 (list args-23293)))
-                  (if (@apply
-                        (lambda (r-23300)
-                          (if (symbol? r-23300)
-                            #t
-                            (if (if (vector? r-23300)
-                                  (if (= (vector-length r-23300) 4)
-                                    (eq? (vector-ref r-23300 0) 'syntax-object)
-                                    #f)
-                                  #f)
-                              (symbol? (vector-ref r-23300 1))
-                              #f)))
-                        tmp-23298)
-                    (@apply
-                      (lambda (r-23330)
-                        (check-22764
-                          req-23294
-                          opt-23295
-                          r-23330
-                          kw-23296))
-                      tmp-23298)
-                    (syntax-violation
-                      'lambda*
-                      "invalid rest argument"
-                      orig-args-22759
-                      args-23293)))))
-            (check-22764
-              (lambda (req-23334 opt-23335 rest-23336 kw-23337)
-                (if (distinct-bound-ids?-4288
-                      (append
-                        req-23334
-                        (map car opt-23335)
-                        (if rest-23336 (list rest-23336) '())
-                        (if (pair? kw-23337)
-                          (map cadr (cdr kw-23337))
-                          '())))
-                  (values req-23334 opt-23335 rest-23336 kw-23337)
-                  (syntax-violation
-                    'lambda*
-                    "duplicate identifier in argument list"
-                    orig-args-22759)))))
-           (req-22760 orig-args-22759 '()))))
-     (expand-lambda-case-4309
-       (lambda (e-23453
-                r-23454
-                w-23455
-                s-23456
-                mod-23457
-                get-formals-23458
-                clauses-23459)
-         (letrec*
-           ((parse-req-23460
-              (lambda (req-23591
-                       opt-23592
-                       rest-23593
-                       kw-23594
-                       body-23595)
-                (let ((vars-23596 (map gen-var-4311 req-23591))
-                      (labels-23597 (gen-labels-4264 req-23591)))
-                  (let ((r*-23598
-                          (extend-var-env-4256
-                            labels-23597
-                            vars-23596
-                            r-23454))
-                        (w*-23599
-                          (make-binding-wrap-4275
-                            req-23591
-                            labels-23597
-                            w-23455)))
-                    (parse-opt-23461
-                      (map syntax->datum req-23591)
-                      opt-23592
-                      rest-23593
-                      kw-23594
-                      body-23595
-                      (reverse vars-23596)
-                      r*-23598
-                      w*-23599
-                      '()
-                      '())))))
-            (parse-opt-23461
-              (lambda (req-23785
-                       opt-23786
-                       rest-23787
-                       kw-23788
-                       body-23789
-                       vars-23790
-                       r*-23791
-                       w*-23792
-                       out-23793
-                       inits-23794)
-                (if (pair? opt-23786)
-                  (let ((tmp-23795 (car opt-23786)))
-                    (let ((tmp-23796 ($sc-dispatch tmp-23795 '(any any))))
-                      (if tmp-23796
-                        (@apply
-                          (lambda (id-23798 i-23799)
-                            (let ((v-23800
-                                    (let ((id-23808
-                                            (if (if (vector? id-23798)
-                                                  (if (= (vector-length
-                                                           id-23798)
-                                                         4)
-                                                    (eq? (vector-ref
-                                                           id-23798
-                                                           0)
-                                                         'syntax-object)
-                                                    #f)
-                                                  #f)
-                                              (vector-ref id-23798 1)
-                                              id-23798)))
-                                      (gensym
-                                        (string-append
-                                          (symbol->string id-23808)
-                                          "-")))))
-                              (let ((l-23801 (gen-labels-4264 (list v-23800))))
-                                (let ((r**-23802
-                                        (extend-var-env-4256
-                                          l-23801
-                                          (list v-23800)
-                                          r*-23791)))
-                                  (let ((w**-23803
-                                          (make-binding-wrap-4275
-                                            (list id-23798)
-                                            l-23801
-                                            w*-23792)))
-                                    (parse-opt-23461
-                                      req-23785
-                                      (cdr opt-23786)
-                                      rest-23787
-                                      kw-23788
-                                      body-23789
-                                      (cons v-23800 vars-23790)
-                                      r**-23802
-                                      w**-23803
-                                      (cons (syntax->datum id-23798) out-23793)
-                                      (cons (call-with-values
-                                              (lambda ()
-                                                (syntax-type-4296
-                                                  i-23799
-                                                  r*-23791
-                                                  w*-23792
-                                                  (let ((props-23882
-                                                          (source-properties
-                                                            (if (if (vector?
-                                                                      i-23799)
-                                                                  (if (= 
(vector-length
-                                                                           
i-23799)
-                                                                         4)
-                                                                    (eq? 
(vector-ref
-                                                                           
i-23799
-                                                                           0)
-                                                                         
'syntax-object)
-                                                                    #f)
-                                                                  #f)
-                                                              (vector-ref
-                                                                i-23799
-                                                                1)
-                                                              i-23799))))
-                                                    (if (pair? props-23882)
-                                                      props-23882
-                                                      #f))
-                                                  #f
-                                                  mod-23457
-                                                  #f))
-                                              (lambda (type-23915
-                                                       value-23916
-                                                       form-23917
-                                                       e-23918
-                                                       w-23919
-                                                       s-23920
-                                                       mod-23921)
-                                                (expand-expr-4298
-                                                  type-23915
-                                                  value-23916
-                                                  form-23917
-                                                  e-23918
-                                                  r*-23791
-                                                  w-23919
-                                                  s-23920
-                                                  mod-23921)))
-                                            inits-23794)))))))
-                          tmp-23796)
+                                     "sequence of zero expressions"
+                                     (source-wrap e w s mod))))
+                               tmp-1)
                         (syntax-violation
                           #f
                           "source expression failed to match any pattern"
-                          tmp-23795))))
-                  (if rest-23787
-                    (let ((v-24035
-                            (let ((id-24045
-                                    (if (if (vector? rest-23787)
-                                          (if (= (vector-length rest-23787) 4)
-                                            (eq? (vector-ref rest-23787 0)
-                                                 'syntax-object)
-                                            #f)
-                                          #f)
-                                      (vector-ref rest-23787 1)
-                                      rest-23787)))
-                              (gensym
-                                (string-append
-                                  (symbol->string id-24045)
-                                  "-")))))
-                      (let ((l-24036 (gen-labels-4264 (list v-24035))))
-                        (let ((r*-24037
-                                (extend-var-env-4256
-                                  l-24036
-                                  (list v-24035)
-                                  r*-23791)))
-                          (let ((w*-24038
-                                  (make-binding-wrap-4275
-                                    (list rest-23787)
-                                    l-24036
-                                    w*-23792)))
-                            (parse-kw-23462
-                              req-23785
-                              (if (pair? out-23793) (reverse out-23793) #f)
-                              (syntax->datum rest-23787)
-                              (if (pair? kw-23788) (cdr kw-23788) kw-23788)
-                              body-23789
-                              (cons v-24035 vars-23790)
-                              r*-24037
-                              w*-24038
-                              (if (pair? kw-23788) (car kw-23788) #f)
-                              '()
-                              inits-23794)))))
-                    (parse-kw-23462
-                      req-23785
-                      (if (pair? out-23793) (reverse out-23793) #f)
+                          tmp))))))
+               ((memv key '(local-syntax-form))
+                (expand-local-syntax value e r w s mod expand-sequence))
+               ((memv key '(eval-when-form))
+                (let* ((tmp-1 e) (tmp ($sc-dispatch tmp-1 '(_ each-any any . 
each-any))))
+                  (if tmp
+                    (apply (lambda (x e1 e2)
+                             (let ((when-list (parse-when-list e x)))
+                               (if (memq 'eval when-list)
+                                 (expand-sequence (cons e1 e2) r w s mod)
+                                 (expand-void))))
+                           tmp)
+                    (syntax-violation
                       #f
-                      (if (pair? kw-23788) (cdr kw-23788) kw-23788)
-                      body-23789
-                      vars-23790
-                      r*-23791
-                      w*-23792
-                      (if (pair? kw-23788) (car kw-23788) #f)
-                      '()
-                      inits-23794)))))
-            (parse-kw-23462
-              (lambda (req-24216
-                       opt-24217
-                       rest-24218
-                       kw-24219
-                       body-24220
-                       vars-24221
-                       r*-24222
-                       w*-24223
-                       aok-24224
-                       out-24225
-                       inits-24226)
-                (if (pair? kw-24219)
-                  (let ((tmp-24227 (car kw-24219)))
-                    (let ((tmp-24228
-                            ($sc-dispatch tmp-24227 '(any any any))))
-                      (if tmp-24228
-                        (@apply
-                          (lambda (k-24230 id-24231 i-24232)
-                            (let ((v-24233
-                                    (let ((id-24241
-                                            (if (if (vector? id-24231)
-                                                  (if (= (vector-length
-                                                           id-24231)
-                                                         4)
-                                                    (eq? (vector-ref
-                                                           id-24231
-                                                           0)
-                                                         'syntax-object)
-                                                    #f)
-                                                  #f)
-                                              (vector-ref id-24231 1)
-                                              id-24231)))
-                                      (gensym
-                                        (string-append
-                                          (symbol->string id-24241)
-                                          "-")))))
-                              (let ((l-24234 (gen-labels-4264 (list v-24233))))
-                                (let ((r**-24235
-                                        (extend-var-env-4256
-                                          l-24234
-                                          (list v-24233)
-                                          r*-24222)))
-                                  (let ((w**-24236
-                                          (make-binding-wrap-4275
-                                            (list id-24231)
-                                            l-24234
-                                            w*-24223)))
-                                    (parse-kw-23462
-                                      req-24216
-                                      opt-24217
-                                      rest-24218
-                                      (cdr kw-24219)
-                                      body-24220
-                                      (cons v-24233 vars-24221)
-                                      r**-24235
-                                      w**-24236
-                                      aok-24224
-                                      (cons (list (syntax->datum k-24230)
-                                                  (syntax->datum id-24231)
-                                                  v-24233)
-                                            out-24225)
-                                      (cons (call-with-values
-                                              (lambda ()
-                                                (syntax-type-4296
-                                                  i-24232
-                                                  r*-24222
-                                                  w*-24223
-                                                  (let ((props-24315
-                                                          (source-properties
-                                                            (if (if (vector?
-                                                                      i-24232)
-                                                                  (if (= 
(vector-length
-                                                                           
i-24232)
-                                                                         4)
-                                                                    (eq? 
(vector-ref
-                                                                           
i-24232
-                                                                           0)
-                                                                         
'syntax-object)
-                                                                    #f)
-                                                                  #f)
-                                                              (vector-ref
-                                                                i-24232
-                                                                1)
-                                                              i-24232))))
-                                                    (if (pair? props-24315)
-                                                      props-24315
-                                                      #f))
-                                                  #f
-                                                  mod-23457
-                                                  #f))
-                                              (lambda (type-24348
-                                                       value-24349
-                                                       form-24350
-                                                       e-24351
-                                                       w-24352
-                                                       s-24353
-                                                       mod-24354)
-                                                (expand-expr-4298
-                                                  type-24348
-                                                  value-24349
-                                                  form-24350
-                                                  e-24351
-                                                  r*-24222
-                                                  w-24352
-                                                  s-24353
-                                                  mod-24354)))
-                                            inits-24226)))))))
-                          tmp-24228)
-                        (syntax-violation
-                          #f
-                          "source expression failed to match any pattern"
-                          tmp-24227))))
-                  (parse-body-23463
-                    req-24216
-                    opt-24217
-                    rest-24218
-                    (if (if aok-24224 aok-24224 (pair? out-24225))
-                      (cons aok-24224 (reverse out-24225))
-                      #f)
-                    body-24220
-                    (reverse vars-24221)
-                    r*-24222
-                    w*-24223
-                    (reverse inits-24226)
-                    '()))))
-            (parse-body-23463
-              (lambda (req-24477
-                       opt-24478
-                       rest-24479
-                       kw-24480
-                       body-24481
-                       vars-24482
-                       r*-24483
-                       w*-24484
-                       inits-24485
-                       meta-24486)
-                (let ((tmp-24488
-                        ($sc-dispatch body-24481 '(any any . each-any))))
-                  (if (if tmp-24488
-                        (@apply
-                          (lambda (docstring-24492 e1-24493 e2-24494)
-                            (string? (syntax->datum docstring-24492)))
-                          tmp-24488)
-                        #f)
-                    (@apply
-                      (lambda (docstring-24495 e1-24496 e2-24497)
-                        (parse-body-23463
-                          req-24477
-                          opt-24478
-                          rest-24479
-                          kw-24480
-                          (cons e1-24496 e2-24497)
-                          vars-24482
-                          r*-24483
-                          w*-24484
-                          inits-24485
-                          (append
-                            meta-24486
-                            (list (cons 'documentation
-                                        (syntax->datum docstring-24495))))))
-                      tmp-24488)
-                    (let ((tmp-24498
-                            ($sc-dispatch
-                              body-24481
-                              '(#(vector #(each (any . any)))
-                                any
-                                .
-                                each-any))))
-                      (if tmp-24498
-                        (@apply
-                          (lambda (k-24502 v-24503 e1-24504 e2-24505)
-                            (parse-body-23463
-                              req-24477
-                              opt-24478
-                              rest-24479
-                              kw-24480
-                              (cons e1-24504 e2-24505)
-                              vars-24482
-                              r*-24483
-                              w*-24484
-                              inits-24485
-                              (append
-                                meta-24486
-                                (syntax->datum (map cons k-24502 v-24503)))))
-                          tmp-24498)
-                        (let ((tmp-24506
-                                ($sc-dispatch body-24481 '(any . each-any))))
-                          (if tmp-24506
-                            (@apply
-                              (lambda (e1-24510 e2-24511)
-                                (values
-                                  meta-24486
-                                  req-24477
-                                  opt-24478
-                                  rest-24479
-                                  kw-24480
-                                  inits-24485
-                                  vars-24482
-                                  (expand-body-4301
-                                    (cons e1-24510 e2-24511)
-                                    (wrap-4290
-                                      (begin
-                                        (if (if s-23456
-                                              (supports-source-properties?
-                                                e-23453)
-                                              #f)
-                                          (set-source-properties!
-                                            e-23453
-                                            s-23456))
-                                        e-23453)
-                                      w-23455
-                                      mod-23457)
-                                    r*-24483
-                                    w*-24484
-                                    mod-23457)))
-                              tmp-24506)
-                            (syntax-violation
+                      "source expression failed to match any pattern"
+                      tmp-1))))
+               ((memv key
+                      '(define-form define-syntax-form 
define-syntax-parameter-form))
+                (syntax-violation
+                  #f
+                  "definition in expression context, where definitions are not 
allowed,"
+                  (source-wrap form w s mod)))
+               ((memv key '(syntax))
+                (syntax-violation
+                  #f
+                  "reference to pattern variable outside syntax form"
+                  (source-wrap e w s mod)))
+               ((memv key '(displaced-lexical))
+                (syntax-violation
+                  #f
+                  "reference to identifier outside its scope"
+                  (source-wrap e w s mod)))
+               (else
+                (syntax-violation #f "unexpected syntax" (source-wrap e w s 
mod)))))))
+   (expand-application
+     (lambda (x e r w s mod)
+       (let* ((tmp-1 e) (tmp ($sc-dispatch tmp-1 '(any . each-any))))
+         (if tmp
+           (apply (lambda (e0 e1)
+                    (build-application s x (map (lambda (e) (expand e r w 
mod)) e1)))
+                  tmp)
+           (syntax-violation
+             #f
+             "source expression failed to match any pattern"
+             tmp-1)))))
+   (expand-macro
+     (lambda (p e r w s rib mod)
+       (letrec*
+         ((rebuild-macro-output
+            (lambda (x m)
+              (cond ((pair? x)
+                     (decorate-source
+                       (cons (rebuild-macro-output (car x) m)
+                             (rebuild-macro-output (cdr x) m))
+                       s))
+                    ((syntax-object? x)
+                     (let ((w (syntax-object-wrap x)))
+                       (let ((ms (car w)) (ss (cdr w)))
+                         (if (and (pair? ms) (eq? (car ms) #f))
+                           (make-syntax-object
+                             (syntax-object-expression x)
+                             (cons (cdr ms) (if rib (cons rib (cdr ss)) (cdr 
ss)))
+                             (syntax-object-module x))
+                           (make-syntax-object
+                             (decorate-source (syntax-object-expression x) s)
+                             (cons (cons m ms)
+                                   (if rib (cons rib (cons 'shift ss)) (cons 
'shift ss)))
+                             (syntax-object-module x))))))
+                    ((vector? x)
+                     (let* ((n (vector-length x)) (v (decorate-source 
(make-vector n) s)))
+                       (let loop ((i 0))
+                         (if (= i n)
+                           (begin (if #f #f) v)
+                           (begin
+                             (vector-set! v i (rebuild-macro-output 
(vector-ref x i) m))
+                             (loop (+ i 1)))))))
+                    ((symbol? x)
+                     (syntax-violation
+                       #f
+                       "encountered raw symbol in macro output"
+                       (source-wrap e w (cdr w) mod)
+                       x))
+                    (else (decorate-source x s))))))
+         (with-fluids
+           ((transformer-environment (lambda (k) (k e r w s rib mod))))
+           (rebuild-macro-output
+             (p (source-wrap e (anti-mark w) s mod))
+             (gensym (string-append "m-" (session-id) "-")))))))
+   (expand-body
+     (lambda (body outer-form r w mod)
+       (let* ((r (cons '("placeholder" placeholder) r))
+              (ribcage (make-ribcage '() '() '()))
+              (w (cons (car w) (cons ribcage (cdr w)))))
+         (let parse ((body (map (lambda (x) (cons r (wrap x w mod))) body))
+                     (ids '())
+                     (labels '())
+                     (var-ids '())
+                     (vars '())
+                     (vals '())
+                     (bindings '()))
+           (if (null? body)
+             (syntax-violation #f "no expressions in body" outer-form)
+             (let ((e (cdar body)) (er (caar body)))
+               (call-with-values
+                 (lambda ()
+                   (syntax-type e er '(()) (source-annotation er) ribcage mod 
#f))
+                 (lambda (type value form e w s mod)
+                   (let ((key type))
+                     (cond ((memv key '(define-form))
+                            (let ((id (wrap value w mod)) (label (gen-label)))
+                              (let ((var (gen-var id)))
+                                (extend-ribcage! ribcage id label)
+                                (parse (cdr body)
+                                       (cons id ids)
+                                       (cons label labels)
+                                       (cons id var-ids)
+                                       (cons var vars)
+                                       (cons (cons er (wrap e w mod)) vals)
+                                       (cons (cons 'lexical var) bindings)))))
+                           ((memv key '(define-syntax-form 
define-syntax-parameter-form))
+                            (let ((id (wrap value w mod)) (label (gen-label)))
+                              (extend-ribcage! ribcage id label)
+                              (parse (cdr body)
+                                     (cons id ids)
+                                     (cons label labels)
+                                     var-ids
+                                     vars
+                                     vals
+                                     (cons (cons 'macro (cons er (wrap e w 
mod))) bindings))))
+                           ((memv key '(begin-form))
+                            (let* ((tmp-1 e) (tmp ($sc-dispatch tmp-1 '(_ . 
each-any))))
+                              (if tmp
+                                (apply (lambda (e1)
+                                         (parse (let f ((forms e1))
+                                                  (if (null? forms)
+                                                    (cdr body)
+                                                    (cons (cons er (wrap (car 
forms) w mod)) (f (cdr forms)))))
+                                                ids
+                                                labels
+                                                var-ids
+                                                vars
+                                                vals
+                                                bindings))
+                                       tmp)
+                                (syntax-violation
+                                  #f
+                                  "source expression failed to match any 
pattern"
+                                  tmp-1))))
+                           ((memv key '(local-syntax-form))
+                            (expand-local-syntax
+                              value
+                              e
+                              er
+                              w
+                              s
+                              mod
+                              (lambda (forms er w s mod)
+                                (parse (let f ((forms forms))
+                                         (if (null? forms)
+                                           (cdr body)
+                                           (cons (cons er (wrap (car forms) w 
mod)) (f (cdr forms)))))
+                                       ids
+                                       labels
+                                       var-ids
+                                       vars
+                                       vals
+                                       bindings))))
+                           ((null? ids)
+                            (build-sequence
                               #f
-                              "source expression failed to match any pattern"
-                              body-24481))))))))))
-           (let ((tmp-23465 ($sc-dispatch clauses-23459 '())))
-             (if tmp-23465
-               (@apply (lambda () (values '() #f)) tmp-23465)
-               (let ((tmp-23469
-                       ($sc-dispatch
-                         clauses-23459
-                         '((any any . each-any)
-                           .
-                           #(each (any any . each-any))))))
-                 (if tmp-23469
-                   (@apply
-                     (lambda (args-23473
-                              e1-23474
-                              e2-23475
-                              args*-23476
-                              e1*-23477
-                              e2*-23478)
-                       (call-with-values
-                         (lambda () (get-formals-23458 args-23473))
-                         (lambda (req-23479 opt-23480 rest-23481 kw-23482)
-                           (call-with-values
-                             (lambda ()
-                               (parse-req-23460
-                                 req-23479
-                                 opt-23480
-                                 rest-23481
-                                 kw-23482
-                                 (cons e1-23474 e2-23475)))
-                             (lambda (meta-23547
-                                      req-23548
-                                      opt-23549
-                                      rest-23550
-                                      kw-23551
-                                      inits-23552
-                                      vars-23553
-                                      body-23554)
-                               (call-with-values
-                                 (lambda ()
-                                   (expand-lambda-case-4309
-                                     e-23453
-                                     r-23454
-                                     w-23455
-                                     s-23456
-                                     mod-23457
-                                     get-formals-23458
-                                     (map (lambda (tmp-2800-23555
-                                                   tmp-2799-23556
-                                                   tmp-2798-23557)
-                                            (cons tmp-2798-23557
-                                                  (cons tmp-2799-23556
-                                                        tmp-2800-23555)))
-                                          e2*-23478
-                                          e1*-23477
-                                          args*-23476)))
-                                 (lambda (meta*-23558 else*-23559)
-                                   (values
-                                     (append meta-23547 meta*-23558)
-                                     (make-struct/no-tail
-                                       (vector-ref %expanded-vtables 14)
-                                       s-23456
-                                       req-23548
-                                       opt-23549
-                                       rest-23550
-                                       kw-23551
-                                       inits-23552
-                                       vars-23553
-                                       body-23554
-                                       else*-23559)))))))))
-                     tmp-23469)
-                   (syntax-violation
-                     #f
-                     "source expression failed to match any pattern"
-                     clauses-23459))))))))
-     (strip-4310
-       (lambda (x-24548 w-24549)
-         (if (memq 'top (car w-24549))
-           x-24548
-           (letrec*
-             ((f-24550
-                (lambda (x-24553)
-                  (if (if (vector? x-24553)
-                        (if (= (vector-length x-24553) 4)
-                          (eq? (vector-ref x-24553 0) 'syntax-object)
-                          #f)
-                        #f)
-                    (strip-4310
-                      (vector-ref x-24553 1)
-                      (vector-ref x-24553 2))
-                    (if (pair? x-24553)
-                      (let ((a-24572 (f-24550 (car x-24553)))
-                            (d-24573 (f-24550 (cdr x-24553))))
-                        (if (if (eq? a-24572 (car x-24553))
-                              (eq? d-24573 (cdr x-24553))
-                              #f)
-                          x-24553
-                          (cons a-24572 d-24573)))
-                      (if (vector? x-24553)
-                        (let ((old-24576 (vector->list x-24553)))
-                          (let ((new-24577 (map f-24550 old-24576)))
-                            (letrec*
-                              ((lp-24578
-                                 (lambda (l1-24654 l2-24655)
-                                   (if (null? l1-24654)
-                                     x-24553
-                                     (if (eq? (car l1-24654) (car l2-24655))
-                                       (lp-24578 (cdr l1-24654) (cdr l2-24655))
-                                       (list->vector new-24577))))))
-                              (lp-24578 old-24576 new-24577))))
-                        x-24553))))))
-             (f-24550 x-24548)))))
-     (gen-var-4311
-       (lambda (id-23603)
-         (let ((id-23604
-                 (if (if (vector? id-23603)
-                       (if (= (vector-length id-23603) 4)
-                         (eq? (vector-ref id-23603 0) 'syntax-object)
-                         #f)
-                       #f)
-                   (vector-ref id-23603 1)
-                   id-23603)))
-           (gensym
-             (string-append (symbol->string id-23604) "-"))))))
-    (begin
-      (set! session-id-4222
-        (let ((v-14702
-                (module-variable
-                  (current-module)
-                  'syntax-session-id)))
-          (lambda () ((variable-ref v-14702)))))
-      (set! transformer-environment-4283
-        (make-fluid
-          (lambda (k-13734)
-            (error "called outside the dynamic extent of a syntax 
transformer"))))
-      (module-define!
-        (current-module)
-        'letrec-syntax
-        (make-syntax-transformer
-          'letrec-syntax
-          'local-syntax
-          #t))
-      (module-define!
-        (current-module)
-        'let-syntax
-        (make-syntax-transformer
-          'let-syntax
-          'local-syntax
-          #f))
-      (global-extend-4259
-        'core
-        'syntax-parameterize
-        (lambda (e-4430 r-4431 w-4432 s-4433 mod-4434)
-          (let ((tmp-4436
-                  ($sc-dispatch
-                    e-4430
-                    '(_ #(each (any any)) any . each-any))))
-            (if (if tmp-4436
-                  (@apply
-                    (lambda (var-4438 val-4439 e1-4440 e2-4441)
-                      (valid-bound-ids?-4287 var-4438))
-                    tmp-4436)
-                  #f)
-              (@apply
-                (lambda (var-4519 val-4520 e1-4521 e2-4522)
-                  (let ((names-4523
-                          (map (lambda (x-4573)
-                                 (id-var-name-4280 x-4573 w-4432))
-                               var-4519)))
-                    (begin
-                      (for-each
-                        (lambda (id-4524 n-4525)
-                          (let ((key-4526
-                                  (car (let ((t-4533 (assq n-4525 r-4431)))
-                                         (if t-4533
-                                           (cdr t-4533)
-                                           (if (symbol? n-4525)
-                                             (let ((t-4538
-                                                     
(get-global-definition-hook-4224
-                                                       n-4525
-                                                       mod-4434)))
-                                               (if t-4538 t-4538 '(global)))
-                                             '(displaced-lexical)))))))
-                            (if (eqv? key-4526 'displaced-lexical)
+                              (map (lambda (x) (expand (cdr x) (car x) '(()) 
mod))
+                                   (cons (cons er (source-wrap e w s mod)) 
(cdr body)))))
+                           (else
+                            (if (not (valid-bound-ids? ids))
                               (syntax-violation
-                                'syntax-parameterize
-                                "identifier out of context"
-                                e-4430
-                                (wrap-4290
-                                  (begin
-                                    (if (if s-4433
-                                          (supports-source-properties? id-4524)
-                                          #f)
-                                      (set-source-properties! id-4524 s-4433))
-                                    id-4524)
-                                  w-4432
-                                  mod-4434)))))
-                        var-4519
-                        names-4523)
-                      (expand-body-4301
-                        (cons e1-4521 e2-4522)
-                        (wrap-4290
-                          (begin
-                            (if (if s-4433
-                                  (supports-source-properties? e-4430)
-                                  #f)
-                              (set-source-properties! e-4430 s-4433))
-                            e-4430)
-                          w-4432
-                          mod-4434)
-                        (extend-env-4255
-                          names-4523
-                          (let ((trans-r-4659 (macros-only-env-4257 r-4431)))
-                            (map (lambda (x-4660)
-                                   (cons 'macro
-                                         (eval-local-transformer-4303
-                                           (call-with-values
-                                             (lambda ()
-                                               (syntax-type-4296
-                                                 x-4660
-                                                 trans-r-4659
-                                                 w-4432
-                                                 (let ((props-4717
-                                                         (source-properties
-                                                           (if (if (vector?
-                                                                     x-4660)
-                                                                 (if (= 
(vector-length
-                                                                          
x-4660)
-                                                                        4)
-                                                                   (eq? 
(vector-ref
-                                                                          
x-4660
-                                                                          0)
-                                                                        
'syntax-object)
-                                                                   #f)
-                                                                 #f)
-                                                             (vector-ref
-                                                               x-4660
-                                                               1)
-                                                             x-4660))))
-                                                   (if (pair? props-4717)
-                                                     props-4717
-                                                     #f))
-                                                 #f
-                                                 mod-4434
-                                                 #f))
-                                             (lambda (type-4750
-                                                      value-4751
-                                                      form-4752
-                                                      e-4753
-                                                      w-4754
-                                                      s-4755
-                                                      mod-4756)
-                                               (expand-expr-4298
-                                                 type-4750
-                                                 value-4751
-                                                 form-4752
-                                                 e-4753
-                                                 trans-r-4659
-                                                 w-4754
-                                                 s-4755
-                                                 mod-4756)))
-                                           mod-4434)))
-                                 val-4520))
-                          r-4431)
-                        w-4432
-                        mod-4434))))
-                tmp-4436)
-              (syntax-violation
-                'syntax-parameterize
-                "bad syntax"
-                (wrap-4290
-                  (begin
-                    (if (if s-4433
-                          (supports-source-properties? e-4430)
-                          #f)
-                      (set-source-properties! e-4430 s-4433))
-                    e-4430)
-                  w-4432
-                  mod-4434))))))
-      (module-define!
-        (current-module)
-        'quote
-        (make-syntax-transformer
-          'quote
-          'core
-          (lambda (e-4855 r-4856 w-4857 s-4858 mod-4859)
-            (let ((tmp-4861 ($sc-dispatch e-4855 '(_ any))))
-              (if tmp-4861
-                (@apply
-                  (lambda (e-4862)
-                    (let ((exp-4866 (strip-4310 e-4862 w-4857)))
-                      (make-struct/no-tail
-                        (vector-ref %expanded-vtables 1)
-                        s-4858
-                        exp-4866)))
-                  tmp-4861)
-                (syntax-violation
-                  'quote
-                  "bad syntax"
-                  (wrap-4290
-                    (begin
-                      (if (if s-4858
-                            (supports-source-properties? e-4855)
-                            #f)
-                        (set-source-properties! e-4855 s-4858))
-                      e-4855)
-                    w-4857
-                    mod-4859)))))))
-      (global-extend-4259
-        'core
-        'syntax
-        (letrec*
-          ((gen-syntax-5078
-             (lambda (src-5175
-                      e-5176
-                      r-5177
-                      maps-5178
-                      ellipsis?-5179
-                      mod-5180)
-               (if (if (symbol? e-5176)
-                     #t
-                     (if (if (vector? e-5176)
-                           (if (= (vector-length e-5176) 4)
-                             (eq? (vector-ref e-5176 0) 'syntax-object)
-                             #f)
-                           #f)
-                       (symbol? (vector-ref e-5176 1))
-                       #f))
-                 (let ((label-5207 (id-var-name-4280 e-5176 '(()))))
-                   (let ((b-5208
-                           (let ((t-5215 (assq label-5207 r-5177)))
-                             (if t-5215
-                               (cdr t-5215)
-                               (if (symbol? label-5207)
-                                 (let ((t-5221
-                                         (get-global-definition-hook-4224
-                                           label-5207
-                                           mod-5180)))
-                                   (if t-5221 t-5221 '(global)))
-                                 '(displaced-lexical))))))
-                     (if (eq? (car b-5208) 'syntax)
-                       (call-with-values
-                         (lambda ()
-                           (let ((var.lev-5230 (cdr b-5208)))
-                             (gen-ref-5079
-                               src-5175
-                               (car var.lev-5230)
-                               (cdr var.lev-5230)
-                               maps-5178)))
-                         (lambda (var-5234 maps-5235)
-                           (values (list 'ref var-5234) maps-5235)))
-                       (if (ellipsis?-5179 e-5176)
+                                #f
+                                "invalid or duplicate identifier in definition"
+                                outer-form))
+                            (let loop ((bs bindings) (er-cache #f) (r-cache 
#f))
+                              (if (not (null? bs))
+                                (let ((b (car bs)))
+                                  (if (eq? (car b) 'macro)
+                                    (let* ((er (cadr b))
+                                           (r-cache (if (eq? er er-cache) 
r-cache (macros-only-env er))))
+                                      (set-cdr!
+                                        b
+                                        (eval-local-transformer (expand (cddr 
b) r-cache '(()) mod) mod))
+                                      (loop (cdr bs) er r-cache))
+                                    (loop (cdr bs) er-cache r-cache)))))
+                            (set-cdr! r (extend-env labels bindings (cdr r)))
+                            (build-letrec
+                              #f
+                              #t
+                              (reverse (map syntax->datum var-ids))
+                              (reverse vars)
+                              (map (lambda (x) (expand (cdr x) (car x) '(()) 
mod)) (reverse vals))
+                              (build-sequence
+                                #f
+                                (map (lambda (x) (expand (cdr x) (car x) '(()) 
mod))
+                                     (cons (cons er (source-wrap e w s mod)) 
(cdr body))))))))))))))))
+   (expand-local-syntax
+     (lambda (rec? e r w s mod k)
+       (let* ((tmp e)
+              (tmp ($sc-dispatch tmp '(_ #(each (any any)) any . each-any))))
+         (if tmp
+           (apply (lambda (id val e1 e2)
+                    (let ((ids id))
+                      (if (not (valid-bound-ids? ids))
+                        (syntax-violation #f "duplicate bound keyword" e)
+                        (let* ((labels (gen-labels ids)) (new-w 
(make-binding-wrap ids labels w)))
+                          (k (cons e1 e2)
+                             (extend-env
+                               labels
+                               (let ((w (if rec? new-w w)) (trans-r 
(macros-only-env r)))
+                                 (map (lambda (x)
+                                        (cons 'macro (eval-local-transformer 
(expand x trans-r w mod) mod)))
+                                      val))
+                               r)
+                             new-w
+                             s
+                             mod)))))
+                  tmp)
+           (syntax-violation
+             #f
+             "bad local syntax definition"
+             (source-wrap e w s mod))))))
+   (eval-local-transformer
+     (lambda (expanded mod)
+       (let ((p (local-eval-hook expanded mod)))
+         (if (procedure? p)
+           p
+           (syntax-violation #f "nonprocedure transformer" p)))))
+   (expand-void (lambda () (build-void #f)))
+   (ellipsis?
+     (lambda (x)
+       (and (nonsymbol-id? x)
+            (free-id=? x '#(syntax-object ... ((top)) (hygiene guile))))))
+   (lambda-formals
+     (lambda (orig-args)
+       (letrec*
+         ((req (lambda (args rreq)
+                 (let* ((tmp args) (tmp-1 ($sc-dispatch tmp '())))
+                   (if tmp-1
+                     (apply (lambda () (check (reverse rreq) #f)) tmp-1)
+                     (let ((tmp-1 ($sc-dispatch tmp '(any . any))))
+                       (if (and tmp-1 (apply (lambda (a b) (id? a)) tmp-1))
+                         (apply (lambda (a b) (req b (cons a rreq))) tmp-1)
+                         (let ((tmp-1 (list tmp)))
+                           (if (and tmp-1 (apply (lambda (r) (id? r)) tmp-1))
+                             (apply (lambda (r) (check (reverse rreq) r)) 
tmp-1)
+                             (let ((else tmp))
+                               (syntax-violation 'lambda "invalid argument 
list" orig-args args))))))))))
+          (check (lambda (req rest)
+                   (if (distinct-bound-ids? (if rest (cons rest req) req))
+                     (values req #f rest #f)
+                     (syntax-violation
+                       'lambda
+                       "duplicate identifier in argument list"
+                       orig-args)))))
+         (req orig-args '()))))
+   (expand-simple-lambda
+     (lambda (e r w s mod req rest meta body)
+       (let* ((ids (if rest (append req (list rest)) req))
+              (vars (map gen-var ids))
+              (labels (gen-labels ids)))
+         (build-simple-lambda
+           s
+           (map syntax->datum req)
+           (and rest (syntax->datum rest))
+           vars
+           meta
+           (expand-body
+             body
+             (source-wrap e w s mod)
+             (extend-var-env labels vars r)
+             (make-binding-wrap ids labels w)
+             mod)))))
+   (lambda*-formals
+     (lambda (orig-args)
+       (letrec*
+         ((req (lambda (args rreq)
+                 (let* ((tmp args) (tmp-1 ($sc-dispatch tmp '())))
+                   (if tmp-1
+                     (apply (lambda () (check (reverse rreq) '() #f '())) 
tmp-1)
+                     (let ((tmp-1 ($sc-dispatch tmp '(any . any))))
+                       (if (and tmp-1 (apply (lambda (a b) (id? a)) tmp-1))
+                         (apply (lambda (a b) (req b (cons a rreq))) tmp-1)
+                         (let ((tmp-1 ($sc-dispatch tmp '(any . any))))
+                           (if (and tmp-1
+                                    (apply (lambda (a b) (eq? (syntax->datum 
a) #:optional)) tmp-1))
+                             (apply (lambda (a b) (opt b (reverse rreq) '())) 
tmp-1)
+                             (let ((tmp-1 ($sc-dispatch tmp '(any . any))))
+                               (if (and tmp-1
+                                        (apply (lambda (a b) (eq? 
(syntax->datum a) #:key)) tmp-1))
+                                 (apply (lambda (a b) (key b (reverse rreq) 
'() '())) tmp-1)
+                                 (let ((tmp-1 ($sc-dispatch tmp '(any any))))
+                                   (if (and tmp-1
+                                            (apply (lambda (a b) (eq? 
(syntax->datum a) #:rest)) tmp-1))
+                                     (apply (lambda (a b) (rest b (reverse 
rreq) '() '())) tmp-1)
+                                     (let ((tmp-1 (list tmp)))
+                                       (if (and tmp-1 (apply (lambda (r) (id? 
r)) tmp-1))
+                                         (apply (lambda (r) (rest r (reverse 
rreq) '() '())) tmp-1)
+                                         (let ((else tmp))
+                                           (syntax-violation
+                                             'lambda*
+                                             "invalid argument list"
+                                             orig-args
+                                             args))))))))))))))))
+          (opt (lambda (args req ropt)
+                 (let* ((tmp args) (tmp-1 ($sc-dispatch tmp '())))
+                   (if tmp-1
+                     (apply (lambda () (check req (reverse ropt) #f '())) 
tmp-1)
+                     (let ((tmp-1 ($sc-dispatch tmp '(any . any))))
+                       (if (and tmp-1 (apply (lambda (a b) (id? a)) tmp-1))
+                         (apply (lambda (a b) (opt b req (cons (cons a '(#f)) 
ropt))) tmp-1)
+                         (let ((tmp-1 ($sc-dispatch tmp '((any any) . any))))
+                           (if (and tmp-1 (apply (lambda (a init b) (id? a)) 
tmp-1))
+                             (apply (lambda (a init b) (opt b req (cons (list 
a init) ropt)))
+                                    tmp-1)
+                             (let ((tmp-1 ($sc-dispatch tmp '(any . any))))
+                               (if (and tmp-1
+                                        (apply (lambda (a b) (eq? 
(syntax->datum a) #:key)) tmp-1))
+                                 (apply (lambda (a b) (key b req (reverse 
ropt) '())) tmp-1)
+                                 (let ((tmp-1 ($sc-dispatch tmp '(any any))))
+                                   (if (and tmp-1
+                                            (apply (lambda (a b) (eq? 
(syntax->datum a) #:rest)) tmp-1))
+                                     (apply (lambda (a b) (rest b req (reverse 
ropt) '())) tmp-1)
+                                     (let ((tmp-1 (list tmp)))
+                                       (if (and tmp-1 (apply (lambda (r) (id? 
r)) tmp-1))
+                                         (apply (lambda (r) (rest r req 
(reverse ropt) '())) tmp-1)
+                                         (let ((else tmp))
+                                           (syntax-violation
+                                             'lambda*
+                                             "invalid optional argument list"
+                                             orig-args
+                                             args))))))))))))))))
+          (key (lambda (args req opt rkey)
+                 (let* ((tmp args) (tmp-1 ($sc-dispatch tmp '())))
+                   (if tmp-1
+                     (apply (lambda () (check req opt #f (cons #f (reverse 
rkey)))) tmp-1)
+                     (let ((tmp-1 ($sc-dispatch tmp '(any . any))))
+                       (if (and tmp-1 (apply (lambda (a b) (id? a)) tmp-1))
+                         (apply (lambda (a b)
+                                  (let* ((tmp (symbol->keyword (syntax->datum 
a))) (k tmp))
+                                    (key b req opt (cons (cons k (cons a 
'(#f))) rkey))))
+                                tmp-1)
+                         (let ((tmp-1 ($sc-dispatch tmp '((any any) . any))))
+                           (if (and tmp-1 (apply (lambda (a init b) (id? a)) 
tmp-1))
+                             (apply (lambda (a init b)
+                                      (let* ((tmp (symbol->keyword 
(syntax->datum a))) (k tmp))
+                                        (key b req opt (cons (list k a init) 
rkey))))
+                                    tmp-1)
+                             (let ((tmp-1 ($sc-dispatch tmp '((any any any) . 
any))))
+                               (if (and tmp-1
+                                        (apply (lambda (a init k b) (and (id? 
a) (keyword? (syntax->datum k))))
+                                               tmp-1))
+                                 (apply (lambda (a init k b) (key b req opt 
(cons (list k a init) rkey)))
+                                        tmp-1)
+                                 (let ((tmp-1 ($sc-dispatch tmp '(any))))
+                                   (if (and tmp-1
+                                            (apply (lambda (aok) (eq? 
(syntax->datum aok) #:allow-other-keys))
+                                                   tmp-1))
+                                     (apply (lambda (aok) (check req opt #f 
(cons #t (reverse rkey))))
+                                            tmp-1)
+                                     (let ((tmp-1 ($sc-dispatch tmp '(any any 
any))))
+                                       (if (and tmp-1
+                                                (apply (lambda (aok a b)
+                                                         (and (eq? 
(syntax->datum aok) #:allow-other-keys)
+                                                              (eq? 
(syntax->datum a) #:rest)))
+                                                       tmp-1))
+                                         (apply (lambda (aok a b) (rest b req 
opt (cons #t (reverse rkey))))
+                                                tmp-1)
+                                         (let ((tmp-1 ($sc-dispatch tmp '(any 
. any))))
+                                           (if (and tmp-1
+                                                    (apply (lambda (aok r)
+                                                             (and (eq? 
(syntax->datum aok) #:allow-other-keys) (id? r)))
+                                                           tmp-1))
+                                             (apply (lambda (aok r) (rest r 
req opt (cons #t (reverse rkey))))
+                                                    tmp-1)
+                                             (let ((tmp-1 ($sc-dispatch tmp 
'(any any))))
+                                               (if (and tmp-1
+                                                        (apply (lambda (a b) 
(eq? (syntax->datum a) #:rest)) tmp-1))
+                                                 (apply (lambda (a b) (rest b 
req opt (cons #f (reverse rkey))))
+                                                        tmp-1)
+                                                 (let ((tmp-1 (list tmp)))
+                                                   (if (and tmp-1 (apply 
(lambda (r) (id? r)) tmp-1))
+                                                     (apply (lambda (r) (rest 
r req opt (cons #f (reverse rkey))))
+                                                            tmp-1)
+                                                     (let ((else tmp))
+                                                       (syntax-violation
+                                                         'lambda*
+                                                         "invalid keyword 
argument list"
+                                                         orig-args
+                                                         
args))))))))))))))))))))))
+          (rest (lambda (args req opt kw)
+                  (let* ((tmp-1 args) (tmp (list tmp-1)))
+                    (if (and tmp (apply (lambda (r) (id? r)) tmp))
+                      (apply (lambda (r) (check req opt r kw)) tmp)
+                      (let ((else tmp-1))
+                        (syntax-violation 'lambda* "invalid rest argument" 
orig-args args))))))
+          (check (lambda (req opt rest kw)
+                   (if (distinct-bound-ids?
+                         (append
+                           req
+                           (map car opt)
+                           (if rest (list rest) '())
+                           (if (pair? kw) (map cadr (cdr kw)) '())))
+                     (values req opt rest kw)
+                     (syntax-violation
+                       'lambda*
+                       "duplicate identifier in argument list"
+                       orig-args)))))
+         (req orig-args '()))))
+   (expand-lambda-case
+     (lambda (e r w s mod get-formals clauses)
+       (letrec*
+         ((parse-req
+            (lambda (req opt rest kw body)
+              (let ((vars (map gen-var req)) (labels (gen-labels req)))
+                (let ((r* (extend-var-env labels vars r))
+                      (w* (make-binding-wrap req labels w)))
+                  (parse-opt
+                    (map syntax->datum req)
+                    opt
+                    rest
+                    kw
+                    body
+                    (reverse vars)
+                    r*
+                    w*
+                    '()
+                    '())))))
+          (parse-opt
+            (lambda (req opt rest kw body vars r* w* out inits)
+              (cond ((pair? opt)
+                     (let* ((tmp-1 (car opt)) (tmp ($sc-dispatch tmp-1 '(any 
any))))
+                       (if tmp
+                         (apply (lambda (id i)
+                                  (let* ((v (gen-var id))
+                                         (l (gen-labels (list v)))
+                                         (r** (extend-var-env l (list v) r*))
+                                         (w** (make-binding-wrap (list id) l 
w*)))
+                                    (parse-opt
+                                      req
+                                      (cdr opt)
+                                      rest
+                                      kw
+                                      body
+                                      (cons v vars)
+                                      r**
+                                      w**
+                                      (cons (syntax->datum id) out)
+                                      (cons (expand i r* w* mod) inits))))
+                                tmp)
                          (syntax-violation
-                           'syntax
-                           "misplaced ellipsis"
-                           src-5175)
-                         (values (list 'quote e-5176) maps-5178)))))
-                 (let ((tmp-5237 ($sc-dispatch e-5176 '(any any))))
-                   (if (if tmp-5237
-                         (@apply
-                           (lambda (dots-5241 e-5242)
-                             (ellipsis?-5179 dots-5241))
-                           tmp-5237)
-                         #f)
-                     (@apply
-                       (lambda (dots-5243 e-5244)
-                         (gen-syntax-5078
-                           src-5175
-                           e-5244
-                           r-5177
-                           maps-5178
-                           (lambda (x-5245) #f)
-                           mod-5180))
-                       tmp-5237)
-                     (let ((tmp-5246 ($sc-dispatch e-5176 '(any any . any))))
-                       (if (if tmp-5246
-                             (@apply
-                               (lambda (x-5250 dots-5251 y-5252)
-                                 (ellipsis?-5179 dots-5251))
-                               tmp-5246)
-                             #f)
-                         (@apply
-                           (lambda (x-5253 dots-5254 y-5255)
-                             (letrec*
-                               ((f-5256
-                                  (lambda (y-5264 k-5265)
-                                    (let ((tmp-5267
-                                            ($sc-dispatch
-                                              y-5264
-                                              '(any . any))))
-                                      (if (if tmp-5267
-                                            (@apply
-                                              (lambda (dots-5269 y-5270)
-                                                (ellipsis?-5179 dots-5269))
-                                              tmp-5267)
-                                            #f)
-                                        (@apply
-                                          (lambda (dots-5271 y-5272)
-                                            (f-5256
-                                              y-5272
-                                              (lambda (maps-5273)
-                                                (call-with-values
-                                                  (lambda ()
-                                                    (k-5265
-                                                      (cons '() maps-5273)))
-                                                  (lambda (x-5274 maps-5275)
-                                                    (if (null? (car maps-5275))
-                                                      (syntax-violation
-                                                        'syntax
-                                                        "extra ellipsis"
-                                                        src-5175)
-                                                      (values
-                                                        (let ((map-env-5279
-                                                                (car 
maps-5275)))
-                                                          (list 'apply
-                                                                '(primitive
-                                                                   append)
-                                                                (gen-map-5081
-                                                                  x-5274
-                                                                  
map-env-5279)))
-                                                        (cdr maps-5275))))))))
-                                          tmp-5267)
-                                        (call-with-values
-                                          (lambda ()
-                                            (gen-syntax-5078
-                                              src-5175
-                                              y-5264
-                                              r-5177
-                                              maps-5178
-                                              ellipsis?-5179
-                                              mod-5180))
-                                          (lambda (y-5281 maps-5282)
-                                            (call-with-values
-                                              (lambda () (k-5265 maps-5282))
-                                              (lambda (x-5283 maps-5284)
-                                                (values
-                                                  (if (equal? y-5281 ''())
-                                                    x-5283
-                                                    (list 'append
-                                                          x-5283
-                                                          y-5281))
-                                                  maps-5284))))))))))
-                               (f-5256
-                                 y-5255
-                                 (lambda (maps-5259)
-                                   (call-with-values
-                                     (lambda ()
-                                       (gen-syntax-5078
-                                         src-5175
-                                         x-5253
-                                         r-5177
-                                         (cons '() maps-5259)
-                                         ellipsis?-5179
-                                         mod-5180))
-                                     (lambda (x-5260 maps-5261)
-                                       (if (null? (car maps-5261))
-                                         (syntax-violation
-                                           'syntax
-                                           "extra ellipsis"
-                                           src-5175)
-                                         (values
-                                           (gen-map-5081
-                                             x-5260
-                                             (car maps-5261))
-                                           (cdr maps-5261)))))))))
-                           tmp-5246)
-                         (let ((tmp-5298 ($sc-dispatch e-5176 '(any . any))))
-                           (if tmp-5298
-                             (@apply
-                               (lambda (x-5302 y-5303)
-                                 (call-with-values
-                                   (lambda ()
-                                     (gen-syntax-5078
-                                       src-5175
-                                       x-5302
-                                       r-5177
-                                       maps-5178
-                                       ellipsis?-5179
-                                       mod-5180))
-                                   (lambda (x-5304 maps-5305)
-                                     (call-with-values
-                                       (lambda ()
-                                         (gen-syntax-5078
-                                           src-5175
-                                           y-5303
-                                           r-5177
-                                           maps-5305
-                                           ellipsis?-5179
-                                           mod-5180))
-                                       (lambda (y-5306 maps-5307)
-                                         (values
-                                           (let ((key-5312 (car y-5306)))
-                                             (if (eqv? key-5312 'quote)
-                                               (if (eq? (car x-5304) 'quote)
-                                                 (list 'quote
-                                                       (cons (car (cdr x-5304))
-                                                             (car (cdr 
y-5306))))
-                                                 (if (eq? (car (cdr y-5306))
-                                                          '())
-                                                   (list 'list x-5304)
-                                                   (list 'cons x-5304 y-5306)))
-                                               (if (eqv? key-5312 'list)
-                                                 (cons 'list
-                                                       (cons x-5304
-                                                             (cdr y-5306)))
-                                                 (list 'cons x-5304 y-5306))))
-                                           maps-5307))))))
-                               tmp-5298)
-                             (let ((tmp-5341
-                                     ($sc-dispatch
-                                       e-5176
-                                       '#(vector (any . each-any)))))
-                               (if tmp-5341
-                                 (@apply
-                                   (lambda (e1-5345 e2-5346)
-                                     (call-with-values
-                                       (lambda ()
-                                         (gen-syntax-5078
-                                           src-5175
-                                           (cons e1-5345 e2-5346)
-                                           r-5177
-                                           maps-5178
-                                           ellipsis?-5179
-                                           mod-5180))
-                                       (lambda (e-5347 maps-5348)
-                                         (values
-                                           (if (eq? (car e-5347) 'list)
-                                             (cons 'vector (cdr e-5347))
-                                             (if (eq? (car e-5347) 'quote)
-                                               (list 'quote
-                                                     (list->vector
-                                                       (car (cdr e-5347))))
-                                               (list 'list->vector e-5347)))
-                                           maps-5348))))
-                                   tmp-5341)
-                                 (values
-                                   (list 'quote e-5176)
-                                   maps-5178))))))))))))
-           (gen-ref-5079
-             (lambda (src-5374 var-5375 level-5376 maps-5377)
-               (if (= level-5376 0)
-                 (values var-5375 maps-5377)
-                 (if (null? maps-5377)
-                   (syntax-violation
-                     'syntax
-                     "missing ellipsis"
-                     src-5374)
-                   (call-with-values
-                     (lambda ()
-                       (gen-ref-5079
-                         src-5374
-                         var-5375
-                         (#{1-}# level-5376)
-                         (cdr maps-5377)))
-                     (lambda (outer-var-5378 outer-maps-5379)
-                       (let ((b-5380 (assq outer-var-5378 (car maps-5377))))
-                         (if b-5380
-                           (values (cdr b-5380) maps-5377)
-                           (let ((inner-var-5382
-                                   (gensym
-                                     (string-append
-                                       (symbol->string 'tmp)
-                                       "-"))))
-                             (values
-                               inner-var-5382
-                               (cons (cons (cons outer-var-5378 inner-var-5382)
-                                           (car maps-5377))
-                                     outer-maps-5379)))))))))))
-           (gen-map-5081
-             (lambda (e-5396 map-env-5397)
-               (let ((formals-5398 (map cdr map-env-5397))
-                     (actuals-5399
-                       (map (lambda (x-5401) (list 'ref (car x-5401)))
-                            map-env-5397)))
-                 (if (eq? (car e-5396) 'ref)
-                   (car actuals-5399)
-                   (if (and-map
-                         (lambda (x-5402)
-                           (if (eq? (car x-5402) 'ref)
-                             (memq (car (cdr x-5402)) formals-5398)
-                             #f))
-                         (cdr e-5396))
-                     (cons 'map
-                           (cons (list 'primitive (car e-5396))
-                                 (map (let ((r-5404
-                                              (map cons
-                                                   formals-5398
-                                                   actuals-5399)))
-                                        (lambda (x-5405)
-                                          (cdr (assq (car (cdr x-5405))
-                                                     r-5404))))
-                                      (cdr e-5396))))
-                     (cons 'map
-                           (cons (list 'lambda formals-5398 e-5396)
-                                 actuals-5399)))))))
-           (regen-5085
-             (lambda (x-5407)
-               (let ((key-5408 (car x-5407)))
-                 (if (eqv? key-5408 'ref)
-                   (let ((name-5418 (car (cdr x-5407)))
-                         (var-5419 (car (cdr x-5407))))
-                     (make-struct/no-tail
-                       (vector-ref %expanded-vtables 3)
-                       #f
-                       name-5418
-                       var-5419))
-                   (if (eqv? key-5408 'primitive)
-                     (let ((name-5431 (car (cdr x-5407))))
-                       (if (equal? (module-name (current-module)) '(guile))
-                         (make-struct/no-tail
-                           (vector-ref %expanded-vtables 7)
                            #f
-                           name-5431)
-                         (make-struct/no-tail
-                           (vector-ref %expanded-vtables 5)
-                           #f
-                           '(guile)
-                           name-5431
-                           #f)))
-                     (if (eqv? key-5408 'quote)
-                       (let ((exp-5449 (car (cdr x-5407))))
-                         (make-struct/no-tail
-                           (vector-ref %expanded-vtables 1)
-                           #f
-                           exp-5449))
-                       (if (eqv? key-5408 'lambda)
-                         (if (list? (car (cdr x-5407)))
-                           (let ((req-5460 (car (cdr x-5407)))
-                                 (vars-5462 (car (cdr x-5407)))
-                                 (exp-5464
-                                   (regen-5085 (car (cdr (cdr x-5407))))))
-                             (let ((body-5469
-                                     (make-struct/no-tail
-                                       (vector-ref %expanded-vtables 14)
-                                       #f
-                                       req-5460
-                                       #f
-                                       #f
-                                       #f
-                                       '()
-                                       vars-5462
-                                       exp-5464
-                                       #f)))
-                               (make-struct/no-tail
-                                 (vector-ref %expanded-vtables 13)
-                                 #f
-                                 '()
-                                 body-5469)))
-                           (error "how did we get here" x-5407))
-                         (let ((fun-exp-5485
-                                 (let ((name-5494 (car x-5407)))
-                                   (if (equal?
-                                         (module-name (current-module))
-                                         '(guile))
-                                     (make-struct/no-tail
-                                       (vector-ref %expanded-vtables 7)
-                                       #f
-                                       name-5494)
-                                     (make-struct/no-tail
-                                       (vector-ref %expanded-vtables 5)
-                                       #f
-                                       '(guile)
-                                       name-5494
-                                       #f))))
-                               (arg-exps-5486 (map regen-5085 (cdr x-5407))))
-                           (make-struct/no-tail
-                             (vector-ref %expanded-vtables 11)
-                             #f
-                             fun-exp-5485
-                             arg-exps-5486))))))))))
-          (lambda (e-5086 r-5087 w-5088 s-5089 mod-5090)
-            (let ((e-5091
-                    (wrap-4290
-                      (begin
-                        (if (if s-5089
-                              (supports-source-properties? e-5086)
-                              #f)
-                          (set-source-properties! e-5086 s-5089))
-                        e-5086)
-                      w-5088
-                      mod-5090)))
-              (let ((tmp-5093 ($sc-dispatch e-5091 '(_ any))))
-                (if tmp-5093
-                  (@apply
-                    (lambda (x-5116)
-                      (call-with-values
-                        (lambda ()
-                          (gen-syntax-5078
-                            e-5091
-                            x-5116
-                            r-5087
-                            '()
-                            ellipsis?-4305
-                            mod-5090))
-                        (lambda (e-5170 maps-5171) (regen-5085 e-5170))))
-                    tmp-5093)
-                  (syntax-violation
-                    'syntax
-                    "bad `syntax' form"
-                    e-5091)))))))
-      (global-extend-4259
-        'core
-        'lambda
-        (lambda (e-5679 r-5680 w-5681 s-5682 mod-5683)
-          (let ((tmp-5685
-                  ($sc-dispatch e-5679 '(_ any any . each-any))))
-            (if tmp-5685
-              (@apply
-                (lambda (args-5687 e1-5688 e2-5689)
-                  (call-with-values
-                    (lambda () (lambda-formals-4306 args-5687))
-                    (lambda (req-5692 opt-5693 rest-5694 kw-5695)
-                      (letrec*
-                        ((lp-5696
-                           (lambda (body-5699 meta-5700)
-                             (let ((tmp-5702
-                                     ($sc-dispatch
-                                       body-5699
-                                       '(any any . each-any))))
-                               (if (if tmp-5702
-                                     (@apply
-                                       (lambda (docstring-5706 e1-5707 e2-5708)
-                                         (string?
-                                           (syntax->datum docstring-5706)))
-                                       tmp-5702)
-                                     #f)
-                                 (@apply
-                                   (lambda (docstring-5709 e1-5710 e2-5711)
-                                     (lp-5696
-                                       (cons e1-5710 e2-5711)
-                                       (append
-                                         meta-5700
-                                         (list (cons 'documentation
-                                                     (syntax->datum
-                                                       docstring-5709))))))
-                                   tmp-5702)
-                                 (let ((tmp-5712
-                                         ($sc-dispatch
-                                           body-5699
-                                           '(#(vector #(each (any . any)))
-                                             any
-                                             .
-                                             each-any))))
-                                   (if tmp-5712
-                                     (@apply
-                                       (lambda (k-5716 v-5717 e1-5718 e2-5719)
-                                         (lp-5696
-                                           (cons e1-5718 e2-5719)
-                                           (append
-                                             meta-5700
-                                             (syntax->datum
-                                               (map cons k-5716 v-5717)))))
-                                       tmp-5712)
-                                     (expand-simple-lambda-4307
-                                       e-5679
-                                       r-5680
-                                       w-5681
-                                       s-5682
-                                       mod-5683
-                                       req-5692
-                                       rest-5694
-                                       meta-5700
-                                       body-5699))))))))
-                        (lp-5696 (cons e1-5688 e2-5689) '())))))
-                tmp-5685)
-              (syntax-violation 'lambda "bad lambda" e-5679)))))
-      (global-extend-4259
-        'core
-        'lambda*
-        (lambda (e-6002 r-6003 w-6004 s-6005 mod-6006)
-          (let ((tmp-6008
-                  ($sc-dispatch e-6002 '(_ any any . each-any))))
-            (if tmp-6008
-              (@apply
-                (lambda (args-6010 e1-6011 e2-6012)
-                  (call-with-values
-                    (lambda ()
-                      (expand-lambda-case-4309
-                        e-6002
-                        r-6003
-                        w-6004
-                        s-6005
-                        mod-6006
-                        lambda*-formals-4308
-                        (list (cons args-6010 (cons e1-6011 e2-6012)))))
-                    (lambda (meta-6015 lcase-6016)
-                      (make-struct/no-tail
-                        (vector-ref %expanded-vtables 13)
-                        s-6005
-                        meta-6015
-                        lcase-6016))))
-                tmp-6008)
-              (syntax-violation 'lambda "bad lambda*" e-6002)))))
-      (global-extend-4259
-        'core
-        'case-lambda
-        (lambda (e-6181 r-6182 w-6183 s-6184 mod-6185)
-          (let ((tmp-6187
-                  ($sc-dispatch
-                    e-6181
-                    '(_ (any any . each-any)
-                        .
-                        #(each (any any . each-any))))))
-            (if tmp-6187
-              (@apply
-                (lambda (args-6189
-                         e1-6190
-                         e2-6191
-                         args*-6192
-                         e1*-6193
-                         e2*-6194)
-                  (call-with-values
-                    (lambda ()
-                      (expand-lambda-case-4309
-                        e-6181
-                        r-6182
-                        w-6183
-                        s-6184
-                        mod-6185
-                        lambda-formals-4306
-                        (cons (cons args-6189 (cons e1-6190 e2-6191))
-                              (map (lambda (tmp-3252-6197
-                                            tmp-3251-6198
-                                            tmp-3250-6199)
-                                     (cons tmp-3250-6199
-                                           (cons tmp-3251-6198 tmp-3252-6197)))
-                                   e2*-6194
-                                   e1*-6193
-                                   args*-6192))))
-                    (lambda (meta-6200 lcase-6201)
-                      (make-struct/no-tail
-                        (vector-ref %expanded-vtables 13)
-                        s-6184
-                        meta-6200
-                        lcase-6201))))
-                tmp-6187)
-              (syntax-violation
-                'case-lambda
-                "bad case-lambda"
-                e-6181)))))
-      (global-extend-4259
-        'core
-        'case-lambda*
-        (lambda (e-6358 r-6359 w-6360 s-6361 mod-6362)
-          (let ((tmp-6364
-                  ($sc-dispatch
-                    e-6358
-                    '(_ (any any . each-any)
-                        .
-                        #(each (any any . each-any))))))
-            (if tmp-6364
-              (@apply
-                (lambda (args-6366
-                         e1-6367
-                         e2-6368
-                         args*-6369
-                         e1*-6370
-                         e2*-6371)
-                  (call-with-values
-                    (lambda ()
-                      (expand-lambda-case-4309
-                        e-6358
-                        r-6359
-                        w-6360
-                        s-6361
-                        mod-6362
-                        lambda*-formals-4308
-                        (cons (cons args-6366 (cons e1-6367 e2-6368))
-                              (map (lambda (tmp-3285-6374
-                                            tmp-3284-6375
-                                            tmp-3283-6376)
-                                     (cons tmp-3283-6376
-                                           (cons tmp-3284-6375 tmp-3285-6374)))
-                                   e2*-6371
-                                   e1*-6370
-                                   args*-6369))))
-                    (lambda (meta-6377 lcase-6378)
-                      (make-struct/no-tail
-                        (vector-ref %expanded-vtables 13)
-                        s-6361
-                        meta-6377
-                        lcase-6378))))
-                tmp-6364)
-              (syntax-violation
-                'case-lambda
-                "bad case-lambda*"
-                e-6358)))))
-      (global-extend-4259
-        'core
-        'let
-        (letrec*
-          ((expand-let-6566
-             (lambda (e-6714
-                      r-6715
-                      w-6716
-                      s-6717
-                      mod-6718
-                      constructor-6719
-                      ids-6720
-                      vals-6721
-                      exps-6722)
-               (if (not (valid-bound-ids?-4287 ids-6720))
-                 (syntax-violation
-                   'let
-                   "duplicate bound variable"
-                   e-6714)
-                 (let ((labels-6800 (gen-labels-4264 ids-6720))
-                       (new-vars-6801 (map gen-var-4311 ids-6720)))
-                   (let ((nw-6802
-                           (make-binding-wrap-4275
-                             ids-6720
-                             labels-6800
-                             w-6716))
-                         (nr-6803
-                           (extend-var-env-4256
-                             labels-6800
-                             new-vars-6801
-                             r-6715)))
-                     (constructor-6719
-                       s-6717
-                       (map syntax->datum ids-6720)
-                       new-vars-6801
-                       (map (lambda (x-6820)
-                              (call-with-values
-                                (lambda ()
-                                  (syntax-type-4296
-                                    x-6820
-                                    r-6715
-                                    w-6716
-                                    (let ((props-6836
-                                            (source-properties
-                                              (if (if (vector? x-6820)
-                                                    (if (= (vector-length
-                                                             x-6820)
-                                                           4)
-                                                      (eq? (vector-ref
-                                                             x-6820
-                                                             0)
-                                                           'syntax-object)
-                                                      #f)
-                                                    #f)
-                                                (vector-ref x-6820 1)
-                                                x-6820))))
-                                      (if (pair? props-6836) props-6836 #f))
-                                    #f
-                                    mod-6718
-                                    #f))
-                                (lambda (type-6869
-                                         value-6870
-                                         form-6871
-                                         e-6872
-                                         w-6873
-                                         s-6874
-                                         mod-6875)
-                                  (expand-expr-4298
-                                    type-6869
-                                    value-6870
-                                    form-6871
-                                    e-6872
-                                    r-6715
-                                    w-6873
-                                    s-6874
-                                    mod-6875))))
-                            vals-6721)
-                       (expand-body-4301
-                         exps-6722
-                         (source-wrap-4291 e-6714 nw-6802 s-6717 mod-6718)
-                         nr-6803
-                         nw-6802
-                         mod-6718))))))))
-          (lambda (e-6567 r-6568 w-6569 s-6570 mod-6571)
-            (let ((tmp-6573
-                    ($sc-dispatch
-                      e-6567
-                      '(_ #(each (any any)) any . each-any))))
-              (if (if tmp-6573
-                    (@apply
-                      (lambda (id-6577 val-6578 e1-6579 e2-6580)
-                        (and-map id?-4261 id-6577))
-                      tmp-6573)
-                    #f)
-                (@apply
-                  (lambda (id-6596 val-6597 e1-6598 e2-6599)
-                    (expand-let-6566
-                      e-6567
-                      r-6568
-                      w-6569
-                      s-6570
-                      mod-6571
-                      build-let-4243
-                      id-6596
-                      val-6597
-                      (cons e1-6598 e2-6599)))
-                  tmp-6573)
-                (let ((tmp-6629
-                        ($sc-dispatch
-                          e-6567
-                          '(_ any #(each (any any)) any . each-any))))
-                  (if (if tmp-6629
-                        (@apply
-                          (lambda (f-6633 id-6634 val-6635 e1-6636 e2-6637)
-                            (if (if (symbol? f-6633)
-                                  #t
-                                  (if (if (vector? f-6633)
-                                        (if (= (vector-length f-6633) 4)
-                                          (eq? (vector-ref f-6633 0)
-                                               'syntax-object)
-                                          #f)
-                                        #f)
-                                    (symbol? (vector-ref f-6633 1))
-                                    #f))
-                              (and-map id?-4261 id-6634)
-                              #f))
-                          tmp-6629)
-                        #f)
-                    (@apply
-                      (lambda (f-6679 id-6680 val-6681 e1-6682 e2-6683)
-                        (expand-let-6566
-                          e-6567
-                          r-6568
-                          w-6569
-                          s-6570
-                          mod-6571
-                          build-named-let-4244
-                          (cons f-6679 id-6680)
-                          val-6681
-                          (cons e1-6682 e2-6683)))
-                      tmp-6629)
-                    (syntax-violation
-                      'let
-                      "bad let"
-                      (wrap-4290
-                        (begin
-                          (if (if s-6570
-                                (supports-source-properties? e-6567)
-                                #f)
-                            (set-source-properties! e-6567 s-6570))
-                          e-6567)
-                        w-6569
-                        mod-6571)))))))))
-      (global-extend-4259
-        'core
-        'letrec
-        (lambda (e-7219 r-7220 w-7221 s-7222 mod-7223)
-          (let ((tmp-7225
-                  ($sc-dispatch
-                    e-7219
-                    '(_ #(each (any any)) any . each-any))))
-            (if (if tmp-7225
-                  (@apply
-                    (lambda (id-7227 val-7228 e1-7229 e2-7230)
-                      (and-map id?-4261 id-7227))
-                    tmp-7225)
-                  #f)
-              (@apply
-                (lambda (id-7246 val-7247 e1-7248 e2-7249)
-                  (if (not (valid-bound-ids?-4287 id-7246))
-                    (syntax-violation
-                      'letrec
-                      "duplicate bound variable"
-                      e-7219)
-                    (let ((labels-7339 (gen-labels-4264 id-7246))
-                          (new-vars-7340 (map gen-var-4311 id-7246)))
-                      (let ((w-7341
-                              (make-binding-wrap-4275
-                                id-7246
-                                labels-7339
-                                w-7221))
-                            (r-7342
-                              (extend-var-env-4256
-                                labels-7339
-                                new-vars-7340
-                                r-7220)))
-                        (build-letrec-4245
-                          s-7222
-                          #f
-                          (map syntax->datum id-7246)
-                          new-vars-7340
-                          (map (lambda (x-7427)
-                                 (expand-4297 x-7427 r-7342 w-7341 mod-7223))
-                               val-7247)
-                          (expand-body-4301
-                            (cons e1-7248 e2-7249)
-                            (wrap-4290
-                              (begin
-                                (if (if s-7222
-                                      (supports-source-properties? e-7219)
-                                      #f)
-                                  (set-source-properties! e-7219 s-7222))
-                                e-7219)
-                              w-7341
-                              mod-7223)
-                            r-7342
-                            w-7341
-                            mod-7223))))))
-                tmp-7225)
-              (syntax-violation
-                'letrec
-                "bad letrec"
-                (wrap-4290
-                  (begin
-                    (if (if s-7222
-                          (supports-source-properties? e-7219)
-                          #f)
-                      (set-source-properties! e-7219 s-7222))
-                    e-7219)
-                  w-7221
-                  mod-7223))))))
-      (global-extend-4259
-        'core
-        'letrec*
-        (lambda (e-7817 r-7818 w-7819 s-7820 mod-7821)
-          (let ((tmp-7823
-                  ($sc-dispatch
-                    e-7817
-                    '(_ #(each (any any)) any . each-any))))
-            (if (if tmp-7823
-                  (@apply
-                    (lambda (id-7825 val-7826 e1-7827 e2-7828)
-                      (and-map id?-4261 id-7825))
-                    tmp-7823)
-                  #f)
-              (@apply
-                (lambda (id-7844 val-7845 e1-7846 e2-7847)
-                  (if (not (valid-bound-ids?-4287 id-7844))
+                           "source expression failed to match any pattern"
+                           tmp-1))))
+                    (rest
+                     (let* ((v (gen-var rest))
+                            (l (gen-labels (list v)))
+                            (r* (extend-var-env l (list v) r*))
+                            (w* (make-binding-wrap (list rest) l w*)))
+                       (parse-kw
+                         req
+                         (and (pair? out) (reverse out))
+                         (syntax->datum rest)
+                         (if (pair? kw) (cdr kw) kw)
+                         body
+                         (cons v vars)
+                         r*
+                         w*
+                         (and (pair? kw) (car kw))
+                         '()
+                         inits)))
+                    (else
+                     (parse-kw
+                       req
+                       (and (pair? out) (reverse out))
+                       #f
+                       (if (pair? kw) (cdr kw) kw)
+                       body
+                       vars
+                       r*
+                       w*
+                       (and (pair? kw) (car kw))
+                       '()
+                       inits)))))
+          (parse-kw
+            (lambda (req opt rest kw body vars r* w* aok out inits)
+              (if (pair? kw)
+                (let* ((tmp-1 (car kw)) (tmp ($sc-dispatch tmp-1 '(any any 
any))))
+                  (if tmp
+                    (apply (lambda (k id i)
+                             (let* ((v (gen-var id))
+                                    (l (gen-labels (list v)))
+                                    (r** (extend-var-env l (list v) r*))
+                                    (w** (make-binding-wrap (list id) l w*)))
+                               (parse-kw
+                                 req
+                                 opt
+                                 rest
+                                 (cdr kw)
+                                 body
+                                 (cons v vars)
+                                 r**
+                                 w**
+                                 aok
+                                 (cons (list (syntax->datum k) (syntax->datum 
id) v) out)
+                                 (cons (expand i r* w* mod) inits))))
+                           tmp)
                     (syntax-violation
-                      'letrec*
-                      "duplicate bound variable"
-                      e-7817)
-                    (let ((labels-7937 (gen-labels-4264 id-7844))
-                          (new-vars-7938 (map gen-var-4311 id-7844)))
-                      (let ((w-7939
-                              (make-binding-wrap-4275
-                                id-7844
-                                labels-7937
-                                w-7819))
-                            (r-7940
-                              (extend-var-env-4256
-                                labels-7937
-                                new-vars-7938
-                                r-7818)))
-                        (build-letrec-4245
-                          s-7820
-                          #t
-                          (map syntax->datum id-7844)
-                          new-vars-7938
-                          (map (lambda (x-8025)
-                                 (expand-4297 x-8025 r-7940 w-7939 mod-7821))
-                               val-7845)
-                          (expand-body-4301
-                            (cons e1-7846 e2-7847)
-                            (wrap-4290
-                              (begin
-                                (if (if s-7820
-                                      (supports-source-properties? e-7817)
-                                      #f)
-                                  (set-source-properties! e-7817 s-7820))
-                                e-7817)
-                              w-7939
-                              mod-7821)
-                            r-7940
-                            w-7939
-                            mod-7821))))))
-                tmp-7823)
-              (syntax-violation
-                'letrec*
-                "bad letrec*"
-                (wrap-4290
-                  (begin
-                    (if (if s-7820
-                          (supports-source-properties? e-7817)
-                          #f)
-                      (set-source-properties! e-7817 s-7820))
-                    e-7817)
-                  w-7819
-                  mod-7821))))))
-      (global-extend-4259
-        'core
-        'set!
-        (lambda (e-8488 r-8489 w-8490 s-8491 mod-8492)
-          (let ((tmp-8494 ($sc-dispatch e-8488 '(_ any any))))
-            (if (if tmp-8494
-                  (@apply
-                    (lambda (id-8498 val-8499)
-                      (if (symbol? id-8498)
-                        #t
-                        (if (if (vector? id-8498)
-                              (if (= (vector-length id-8498) 4)
-                                (eq? (vector-ref id-8498 0) 'syntax-object)
-                                #f)
-                              #f)
-                          (symbol? (vector-ref id-8498 1))
-                          #f)))
-                    tmp-8494)
-                  #f)
-              (@apply
-                (lambda (id-8526 val-8527)
-                  (let ((n-8528 (id-var-name-4280 id-8526 w-8490))
-                        (id-mod-8529
-                          (if (if (vector? id-8526)
-                                (if (= (vector-length id-8526) 4)
-                                  (eq? (vector-ref id-8526 0) 'syntax-object)
-                                  #f)
-                                #f)
-                            (vector-ref id-8526 3)
-                            mod-8492)))
-                    (let ((b-8530
-                            (let ((t-8571 (assq n-8528 r-8489)))
-                              (if t-8571
-                                (cdr t-8571)
-                                (if (symbol? n-8528)
-                                  (let ((t-8576
-                                          (get-global-definition-hook-4224
-                                            n-8528
-                                            id-mod-8529)))
-                                    (if t-8576 t-8576 '(global)))
-                                  '(displaced-lexical))))))
-                      (let ((key-8531 (car b-8530)))
-                        (if (eqv? key-8531 'lexical)
-                          (let ((name-8588 (syntax->datum id-8526))
-                                (var-8589 (cdr b-8530))
-                                (exp-8590
+                      #f
+                      "source expression failed to match any pattern"
+                      tmp-1)))
+                (parse-body
+                  req
+                  opt
+                  rest
+                  (and (or aok (pair? out)) (cons aok (reverse out)))
+                  body
+                  (reverse vars)
+                  r*
+                  w*
+                  (reverse inits)
+                  '()))))
+          (parse-body
+            (lambda (req opt rest kw body vars r* w* inits meta)
+              (let* ((tmp body) (tmp-1 ($sc-dispatch tmp '(any any . 
each-any))))
+                (if (and tmp-1
+                         (apply (lambda (docstring e1 e2) (string? 
(syntax->datum docstring)))
+                                tmp-1))
+                  (apply (lambda (docstring e1 e2)
+                           (parse-body
+                             req
+                             opt
+                             rest
+                             kw
+                             (cons e1 e2)
+                             vars
+                             r*
+                             w*
+                             inits
+                             (append meta (list (cons 'documentation 
(syntax->datum docstring))))))
+                         tmp-1)
+                  (let ((tmp-1 ($sc-dispatch tmp '(#(vector #(each (any . 
any))) any . each-any))))
+                    (if tmp-1
+                      (apply (lambda (k v e1 e2)
+                               (parse-body
+                                 req
+                                 opt
+                                 rest
+                                 kw
+                                 (cons e1 e2)
+                                 vars
+                                 r*
+                                 w*
+                                 inits
+                                 (append meta (syntax->datum (map cons k v)))))
+                             tmp-1)
+                      (let ((tmp-1 ($sc-dispatch tmp '(any . each-any))))
+                        (if tmp-1
+                          (apply (lambda (e1 e2)
+                                   (values
+                                     meta
+                                     req
+                                     opt
+                                     rest
+                                     kw
+                                     inits
+                                     vars
+                                     (expand-body (cons e1 e2) (source-wrap e 
w s mod) r* w* mod)))
+                                 tmp-1)
+                          (syntax-violation
+                            #f
+                            "source expression failed to match any pattern"
+                            tmp))))))))))
+         (let* ((tmp clauses) (tmp-1 ($sc-dispatch tmp '())))
+           (if tmp-1
+             (apply (lambda () (values '() #f)) tmp-1)
+             (let ((tmp-1 ($sc-dispatch
+                            tmp
+                            '((any any . each-any) . #(each (any any . 
each-any))))))
+               (if tmp-1
+                 (apply (lambda (args e1 e2 args* e1* e2*)
+                          (call-with-values
+                            (lambda () (get-formals args))
+                            (lambda (req opt rest kw)
+                              (call-with-values
+                                (lambda () (parse-req req opt rest kw (cons e1 
e2)))
+                                (lambda (meta req opt rest kw inits vars body)
                                   (call-with-values
                                     (lambda ()
-                                      (syntax-type-4296
-                                        val-8527
-                                        r-8489
-                                        w-8490
-                                        (let ((props-8611
-                                                (source-properties
-                                                  (if (if (vector? val-8527)
-                                                        (if (= (vector-length
-                                                                 val-8527)
-                                                               4)
-                                                          (eq? (vector-ref
-                                                                 val-8527
-                                                                 0)
-                                                               'syntax-object)
-                                                          #f)
-                                                        #f)
-                                                    (vector-ref val-8527 1)
-                                                    val-8527))))
-                                          (if (pair? props-8611)
-                                            props-8611
-                                            #f))
-                                        #f
-                                        mod-8492
-                                        #f))
-                                    (lambda (type-8644
-                                             value-8645
-                                             form-8646
-                                             e-8647
-                                             w-8648
-                                             s-8649
-                                             mod-8650)
-                                      (expand-expr-4298
-                                        type-8644
-                                        value-8645
-                                        form-8646
-                                        e-8647
-                                        r-8489
-                                        w-8648
-                                        s-8649
-                                        mod-8650)))))
-                            (begin
-                              (if (if (struct? exp-8590)
-                                    (eq? (struct-vtable exp-8590)
-                                         (vector-ref %expanded-vtables 13))
-                                    #f)
-                                (let ((meta-8662 (struct-ref exp-8590 1)))
-                                  (if (not (assq 'name meta-8662))
-                                    (let ((v-8669
-                                            (cons (cons 'name name-8588)
-                                                  meta-8662)))
-                                      (struct-set! exp-8590 1 v-8669)))))
-                              (make-struct/no-tail
-                                (vector-ref %expanded-vtables 4)
-                                s-8491
-                                name-8588
-                                var-8589
-                                exp-8590)))
-                          (if (eqv? key-8531 'global)
-                            (let ((exp-8685
-                                    (call-with-values
-                                      (lambda ()
-                                        (syntax-type-4296
-                                          val-8527
-                                          r-8489
-                                          w-8490
-                                          (let ((props-8707
-                                                  (source-properties
-                                                    (if (if (vector? val-8527)
-                                                          (if (= (vector-length
-                                                                   val-8527)
-                                                                 4)
-                                                            (eq? (vector-ref
-                                                                   val-8527
-                                                                   0)
-                                                                 
'syntax-object)
-                                                            #f)
-                                                          #f)
-                                                      (vector-ref val-8527 1)
-                                                      val-8527))))
-                                            (if (pair? props-8707)
-                                              props-8707
-                                              #f))
-                                          #f
-                                          mod-8492
-                                          #f))
-                                      (lambda (type-8740
-                                               value-8741
-                                               form-8742
-                                               e-8743
-                                               w-8744
-                                               s-8745
-                                               mod-8746)
-                                        (expand-expr-4298
-                                          type-8740
-                                          value-8741
-                                          form-8742
-                                          e-8743
-                                          r-8489
-                                          w-8744
-                                          s-8745
-                                          mod-8746)))))
-                              (begin
-                                (if (if (struct? exp-8685)
-                                      (eq? (struct-vtable exp-8685)
-                                           (vector-ref %expanded-vtables 13))
-                                      #f)
-                                  (let ((meta-8758 (struct-ref exp-8685 1)))
-                                    (if (not (assq 'name meta-8758))
-                                      (let ((v-8765
-                                              (cons (cons 'name n-8528)
-                                                    meta-8758)))
-                                        (struct-set! exp-8685 1 v-8765)))))
-                                (analyze-variable-4233
-                                  id-mod-8529
-                                  n-8528
-                                  (lambda (mod-8773 var-8774 public?-8775)
-                                    (make-struct/no-tail
-                                      (vector-ref %expanded-vtables 6)
-                                      s-8491
-                                      mod-8773
-                                      var-8774
-                                      public?-8775
-                                      exp-8685))
-                                  (lambda (var-8784)
-                                    (make-struct/no-tail
-                                      (vector-ref %expanded-vtables 8)
-                                      s-8491
-                                      var-8784
-                                      exp-8685)))))
-                            (if (eqv? key-8531 'macro)
-                              (let ((p-8794 (cdr b-8530)))
-                                (if (procedure-property
-                                      p-8794
-                                      'variable-transformer)
-                                  (let ((e-8799
-                                          (expand-macro-4300
-                                            p-8794
-                                            e-8488
-                                            r-8489
-                                            w-8490
-                                            s-8491
-                                            #f
-                                            mod-8492)))
-                                    (call-with-values
-                                      (lambda ()
-                                        (syntax-type-4296
-                                          e-8799
-                                          r-8489
-                                          '(())
-                                          (let ((props-8810
-                                                  (source-properties
-                                                    (if (if (vector? e-8799)
-                                                          (if (= (vector-length
-                                                                   e-8799)
-                                                                 4)
-                                                            (eq? (vector-ref
-                                                                   e-8799
-                                                                   0)
-                                                                 
'syntax-object)
-                                                            #f)
-                                                          #f)
-                                                      (vector-ref e-8799 1)
-                                                      e-8799))))
-                                            (if (pair? props-8810)
-                                              props-8810
-                                              #f))
-                                          #f
-                                          mod-8492
-                                          #f))
-                                      (lambda (type-8833
-                                               value-8834
-                                               form-8835
-                                               e-8836
-                                               w-8837
-                                               s-8838
-                                               mod-8839)
-                                        (expand-expr-4298
-                                          type-8833
-                                          value-8834
-                                          form-8835
-                                          e-8836
-                                          r-8489
-                                          w-8837
-                                          s-8838
-                                          mod-8839))))
-                                  (syntax-violation
-                                    'set!
-                                    "not a variable transformer"
-                                    (wrap-4290 e-8488 w-8490 mod-8492)
-                                    (wrap-4290 id-8526 w-8490 id-mod-8529))))
-                              (if (eqv? key-8531 'displaced-lexical)
-                                (syntax-violation
-                                  'set!
-                                  "identifier out of context"
-                                  (wrap-4290 id-8526 w-8490 mod-8492))
-                                (syntax-violation
-                                  'set!
-                                  "bad set!"
-                                  (wrap-4290
-                                    (begin
-                                      (if (if s-8491
-                                            (supports-source-properties?
-                                              e-8488)
-                                            #f)
-                                        (set-source-properties! e-8488 s-8491))
-                                      e-8488)
-                                    w-8490
-                                    mod-8492))))))))))
-                tmp-8494)
-              (let ((tmp-8874
-                      ($sc-dispatch e-8488 '(_ (any . each-any) any))))
-                (if tmp-8874
-                  (@apply
-                    (lambda (head-8878 tail-8879 val-8880)
+                                      (expand-lambda-case
+                                        e
+                                        r
+                                        w
+                                        s
+                                        mod
+                                        get-formals
+                                        (map (lambda (tmp-2 tmp-1 tmp) (cons 
tmp (cons tmp-1 tmp-2)))
+                                             e2*
+                                             e1*
+                                             args*)))
+                                    (lambda (meta* else*)
+                                      (values
+                                        (append meta meta*)
+                                        (build-lambda-case s req opt rest kw 
inits vars body else*)))))))))
+                        tmp-1)
+                 (syntax-violation
+                   #f
+                   "source expression failed to match any pattern"
+                   tmp))))))))
+   (strip (lambda (x w)
+            (if (memq 'top (car w))
+              x
+              (let f ((x x))
+                (cond ((syntax-object? x)
+                       (strip (syntax-object-expression x) (syntax-object-wrap 
x)))
+                      ((pair? x)
+                       (let ((a (f (car x))) (d (f (cdr x))))
+                         (if (and (eq? a (car x)) (eq? d (cdr x))) x (cons a 
d))))
+                      ((vector? x)
+                       (let* ((old (vector->list x)) (new (map f old)))
+                         (let lp ((l1 old) (l2 new))
+                           (cond ((null? l1) x)
+                                 ((eq? (car l1) (car l2)) (lp (cdr l1) (cdr 
l2)))
+                                 (else (list->vector new))))))
+                      (else x))))))
+   (gen-var
+     (lambda (id)
+       (let ((id (if (syntax-object? id) (syntax-object-expression id) id)))
+         (gensym (string-append (symbol->string id) "-")))))
+   (lambda-var-list
+     (lambda (vars)
+       (let lvl ((vars vars) (ls '()) (w '(())))
+         (cond ((pair? vars) (lvl (cdr vars) (cons (wrap (car vars) w #f) ls) 
w))
+               ((id? vars) (cons (wrap vars w #f) ls))
+               ((null? vars) ls)
+               ((syntax-object? vars)
+                (lvl (syntax-object-expression vars)
+                     ls
+                     (join-wraps w (syntax-object-wrap vars))))
+               (else (cons vars ls)))))))
+  (global-extend 'local-syntax 'letrec-syntax #t)
+  (global-extend 'local-syntax 'let-syntax #f)
+  (global-extend
+    'core
+    'syntax-parameterize
+    (lambda (e r w s mod)
+      (let* ((tmp e)
+             (tmp ($sc-dispatch tmp '(_ #(each (any any)) any . each-any))))
+        (if (and tmp (apply (lambda (var val e1 e2) (valid-bound-ids? var)) 
tmp))
+          (apply (lambda (var val e1 e2)
+                   (let ((names (map (lambda (x) (id-var-name x w)) var)))
+                     (for-each
+                       (lambda (id n)
+                         (let ((key (car (lookup n r mod))))
+                           (if (memv key '(displaced-lexical))
+                             (syntax-violation
+                               'syntax-parameterize
+                               "identifier out of context"
+                               e
+                               (source-wrap id w s mod)))))
+                       var
+                       names)
+                     (expand-body
+                       (cons e1 e2)
+                       (source-wrap e w s mod)
+                       (extend-env
+                         names
+                         (let ((trans-r (macros-only-env r)))
+                           (map (lambda (x)
+                                  (cons 'macro (eval-local-transformer (expand 
x trans-r w mod) mod)))
+                                val))
+                         r)
+                       w
+                       mod)))
+                 tmp)
+          (syntax-violation
+            'syntax-parameterize
+            "bad syntax"
+            (source-wrap e w s mod))))))
+  (global-extend
+    'core
+    'quote
+    (lambda (e r w s mod)
+      (let* ((tmp e) (tmp ($sc-dispatch tmp '(_ any))))
+        (if tmp
+          (apply (lambda (e) (build-data s (strip e w))) tmp)
+          (syntax-violation 'quote "bad syntax" (source-wrap e w s mod))))))
+  (global-extend
+    'core
+    'syntax
+    (letrec*
+      ((gen-syntax
+         (lambda (src e r maps ellipsis? mod)
+           (if (id? e)
+             (let* ((label (id-var-name e '(()))) (b (lookup label r mod)))
+               (cond ((eq? (car b) 'syntax)
                       (call-with-values
                         (lambda ()
-                          (syntax-type-4296
-                            head-8878
-                            r-8489
-                            '(())
-                            #f
-                            #f
-                            mod-8492
-                            #t))
-                        (lambda (type-8883
-                                 value-8884
-                                 formform-8885
-                                 ee-8886
-                                 ww-8887
-                                 ss-8888
-                                 modmod-8889)
-                          (if (eqv? type-8883 'module-ref)
-                            (let ((val-8895
+                          (let ((var.lev (cdr b)))
+                            (gen-ref src (car var.lev) (cdr var.lev) maps)))
+                        (lambda (var maps) (values (list 'ref var) maps))))
+                     ((ellipsis? e) (syntax-violation 'syntax "misplaced 
ellipsis" src))
+                     (else (values (list 'quote e) maps))))
+             (let* ((tmp e) (tmp-1 ($sc-dispatch tmp '(any any))))
+               (if (and tmp-1 (apply (lambda (dots e) (ellipsis? dots)) tmp-1))
+                 (apply (lambda (dots e) (gen-syntax src e r maps (lambda (x) 
#f) mod))
+                        tmp-1)
+                 (let ((tmp-1 ($sc-dispatch tmp '(any any . any))))
+                   (if (and tmp-1 (apply (lambda (x dots y) (ellipsis? dots)) 
tmp-1))
+                     (apply (lambda (x dots y)
+                              (let f ((y y)
+                                      (k (lambda (maps)
+                                           (call-with-values
+                                             (lambda () (gen-syntax src x r 
(cons '() maps) ellipsis? mod))
+                                             (lambda (x maps)
+                                               (if (null? (car maps))
+                                                 (syntax-violation 'syntax 
"extra ellipsis" src)
+                                                 (values (gen-map x (car 
maps)) (cdr maps))))))))
+                                (let* ((tmp y) (tmp ($sc-dispatch tmp '(any . 
any))))
+                                  (if (and tmp (apply (lambda (dots y) 
(ellipsis? dots)) tmp))
+                                    (apply (lambda (dots y)
+                                             (f y
+                                                (lambda (maps)
+                                                  (call-with-values
+                                                    (lambda () (k (cons '() 
maps)))
+                                                    (lambda (x maps)
+                                                      (if (null? (car maps))
+                                                        (syntax-violation 
'syntax "extra ellipsis" src)
+                                                        (values (gen-mappend x 
(car maps)) (cdr maps))))))))
+                                           tmp)
                                     (call-with-values
-                                      (lambda ()
-                                        (syntax-type-4296
-                                          val-8880
-                                          r-8489
-                                          w-8490
-                                          (let ((props-8962
-                                                  (source-properties
-                                                    (if (if (vector? val-8880)
-                                                          (if (= (vector-length
-                                                                   val-8880)
-                                                                 4)
-                                                            (eq? (vector-ref
-                                                                   val-8880
-                                                                   0)
-                                                                 
'syntax-object)
-                                                            #f)
-                                                          #f)
-                                                      (vector-ref val-8880 1)
-                                                      val-8880))))
-                                            (if (pair? props-8962)
-                                              props-8962
-                                              #f))
-                                          #f
-                                          mod-8492
-                                          #f))
-                                      (lambda (type-8995
-                                               value-8996
-                                               form-8997
-                                               e-8998
-                                               w-8999
-                                               s-9000
-                                               mod-9001)
-                                        (expand-expr-4298
-                                          type-8995
-                                          value-8996
-                                          form-8997
-                                          e-8998
-                                          r-8489
-                                          w-8999
-                                          s-9000
-                                          mod-9001)))))
-                              (call-with-values
-                                (lambda ()
-                                  (value-8884
-                                    (cons head-8878 tail-8879)
-                                    r-8489
-                                    w-8490))
-                                (lambda (e-8896 r-8897 w-8898 s*-8899 mod-8900)
-                                  (let ((tmp-8902 (list e-8896)))
-                                    (if (@apply
-                                          (lambda (e-8904)
-                                            (if (symbol? e-8904)
-                                              #t
-                                              (if (if (vector? e-8904)
-                                                    (if (= (vector-length
-                                                             e-8904)
-                                                           4)
-                                                      (eq? (vector-ref
-                                                             e-8904
-                                                             0)
-                                                           'syntax-object)
-                                                      #f)
-                                                    #f)
-                                                (symbol? (vector-ref e-8904 1))
-                                                #f)))
-                                          tmp-8902)
-                                      (@apply
-                                        (lambda (e-8934)
-                                          (let ((var-8939
-                                                  (syntax->datum e-8934)))
-                                            (begin
-                                              (if (if (struct? val-8895)
-                                                    (eq? (struct-vtable
-                                                           val-8895)
-                                                         (vector-ref
-                                                           %expanded-vtables
-                                                           13))
-                                                    #f)
-                                                (let ((meta-9017
-                                                        (struct-ref
-                                                          val-8895
-                                                          1)))
-                                                  (if (not (assq 'name
-                                                                 meta-9017))
-                                                    (let ((v-9026
-                                                            (cons (cons 'name
-                                                                        
var-8939)
-                                                                  meta-9017)))
-                                                      (struct-set!
-                                                        val-8895
-                                                        1
-                                                        v-9026)))))
-                                              (analyze-variable-4233
-                                                mod-8900
-                                                var-8939
-                                                (lambda (mod-9032
-                                                         var-9033
-                                                         public?-9034)
-                                                  (make-struct/no-tail
-                                                    (vector-ref
-                                                      %expanded-vtables
-                                                      6)
-                                                    s-8491
-                                                    mod-9032
-                                                    var-9033
-                                                    public?-9034
-                                                    val-8895))
-                                                (lambda (var-9045)
-                                                  (make-struct/no-tail
-                                                    (vector-ref
-                                                      %expanded-vtables
-                                                      8)
-                                                    s-8491
-                                                    var-9045
-                                                    val-8895))))))
-                                        tmp-8902)
-                                      (syntax-violation
-                                        #f
-                                        "source expression failed to match any 
pattern"
-                                        e-8896))))))
-                            (let ((fun-exp-9061
-                                    (let ((e-9069
-                                            (list '#(syntax-object
-                                                     setter
-                                                     ((top)
-                                                      #(ribcage () () ())
-                                                      #(ribcage
-                                                        #(key)
-                                                        #((m-*-3526 top))
-                                                        #("l-*-3527"))
-                                                      #(ribcage () () ())
-                                                      #(ribcage () () ())
-                                                      #(ribcage
-                                                        #(type
-                                                          value
-                                                          formform
-                                                          ee
-                                                          ww
-                                                          ss
-                                                          modmod)
-                                                        #((top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top))
-                                                        #("l-*-3519"
-                                                          "l-*-3520"
-                                                          "l-*-3521"
-                                                          "l-*-3522"
-                                                          "l-*-3523"
-                                                          "l-*-3524"
-                                                          "l-*-3525"))
-                                                      #(ribcage
-                                                        #(head tail val)
-                                                        #((top) (top) (top))
-                                                        #("l-*-3504"
-                                                          "l-*-3505"
-                                                          "l-*-3506"))
-                                                      #(ribcage () () ())
-                                                      #(ribcage
-                                                        #(e r w s mod)
-                                                        #((top)
-                                                          (top)
-                                                          (top)
-                                                          (top)
-                                                          (top))
-                                                        #("l-*-3473"
-                                                          "l-*-3474"
-                                                          "l-*-3475"
-                                                          "l-*-3476"
-                                                          "l-*-3477"))
-                                                      #(ribcage
-                                                        (lambda-var-list
-                                                          gen-var
-                                                          strip
-                                                          expand-lambda-case
-                                                          lambda*-formals
-                                                          expand-simple-lambda
-                                                          lambda-formals
-                                                          ellipsis?
-                                                          expand-void
-                                                          
eval-local-transformer
-                                                          expand-local-syntax
-                                                          expand-body
-                                                          expand-macro
-                                                          expand-application
-                                                          expand-expr
-                                                          expand
-                                                          syntax-type
-                                                          parse-when-list
-                                                          expand-install-global
-                                                          expand-top-sequence
-                                                          expand-sequence
-                                                          source-wrap
-                                                          wrap
-                                                          bound-id-member?
-                                                          distinct-bound-ids?
-                                                          valid-bound-ids?
-                                                          bound-id=?
-                                                          free-id=?
-                                                          
with-transformer-environment
-                                                          
transformer-environment
-                                                          resolve-identifier
-                                                          
locally-bound-identifiers
-                                                          id-var-name
-                                                          same-marks?
-                                                          join-marks
-                                                          join-wraps
-                                                          smart-append
-                                                          make-binding-wrap
-                                                          extend-ribcage!
-                                                          make-empty-ribcage
-                                                          new-mark
-                                                          anti-mark
-                                                          the-anti-mark
-                                                          top-marked?
-                                                          top-wrap
-                                                          empty-wrap
-                                                          set-ribcage-labels!
-                                                          set-ribcage-marks!
-                                                          set-ribcage-symnames!
-                                                          ribcage-labels
-                                                          ribcage-marks
-                                                          ribcage-symnames
-                                                          ribcage?
-                                                          make-ribcage
-                                                          gen-labels
-                                                          gen-label
-                                                          make-rename
-                                                          rename-marks
-                                                          rename-new
-                                                          rename-old
-                                                          subst-rename?
-                                                          wrap-subst
-                                                          wrap-marks
-                                                          make-wrap
-                                                          id-sym-name&marks
-                                                          id-sym-name
-                                                          id?
-                                                          nonsymbol-id?
-                                                          global-extend
-                                                          lookup
-                                                          macros-only-env
-                                                          extend-var-env
-                                                          extend-env
-                                                          null-env
-                                                          binding-value
-                                                          binding-type
-                                                          make-binding
-                                                          arg-check
-                                                          source-annotation
-                                                          no-source
-                                                          
set-syntax-object-module!
-                                                          
set-syntax-object-wrap!
-                                                          
set-syntax-object-expression!
-                                                          syntax-object-module
-                                                          syntax-object-wrap
-                                                          
syntax-object-expression
-                                                          syntax-object?
-                                                          make-syntax-object
-                                                          build-lexical-var
-                                                          build-letrec
-                                                          build-named-let
-                                                          build-let
-                                                          build-sequence
-                                                          build-data
-                                                          build-primref
-                                                          build-lambda-case
-                                                          build-case-lambda
-                                                          build-simple-lambda
-                                                          
build-global-definition
-                                                          
build-global-assignment
-                                                          
build-global-reference
-                                                          analyze-variable
-                                                          
build-lexical-assignment
-                                                          
build-lexical-reference
-                                                          build-dynlet
-                                                          build-conditional
-                                                          build-application
-                                                          build-void
-                                                          maybe-name-value!
-                                                          decorate-source
-                                                          
get-global-definition-hook
-                                                          
put-global-definition-hook
-                                                          session-id
-                                                          local-eval-hook
-                                                          top-level-eval-hook
-                                                          fx<
-                                                          fx=
-                                                          fx-
-                                                          fx+
-                                                          set-lambda-meta!
-                                                          lambda-meta
-                                                          lambda?
-                                                          make-dynlet
-                                                          make-letrec
-                                                          make-let
-                                                          make-lambda-case
-                                                          make-lambda
-                                                          make-sequence
-                                                          make-application
-                                                          make-conditional
-                                                          make-toplevel-define
-                                                          make-toplevel-set
-                                                          make-toplevel-ref
-                                                          make-module-set
-                                                          make-module-ref
-                                                          make-lexical-set
-                                                          make-lexical-ref
-                                                          make-primitive-ref
-                                                          make-const
-                                                          make-void)
-                                                        ((top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top)
-                                                         (top))
-                                                        ("l-*-476"
-                                                         "l-*-474"
-                                                         "l-*-472"
-                                                         "l-*-470"
-                                                         "l-*-468"
-                                                         "l-*-466"
-                                                         "l-*-464"
-                                                         "l-*-462"
-                                                         "l-*-460"
-                                                         "l-*-458"
-                                                         "l-*-456"
-                                                         "l-*-454"
-                                                         "l-*-452"
-                                                         "l-*-450"
-                                                         "l-*-448"
-                                                         "l-*-446"
-                                                         "l-*-444"
-                                                         "l-*-442"
-                                                         "l-*-440"
-                                                         "l-*-438"
-                                                         "l-*-436"
-                                                         "l-*-434"
-                                                         "l-*-432"
-                                                         "l-*-430"
-                                                         "l-*-428"
-                                                         "l-*-426"
-                                                         "l-*-424"
-                                                         "l-*-422"
-                                                         "l-*-420"
-                                                         "l-*-418"
-                                                         "l-*-416"
-                                                         "l-*-414"
-                                                         "l-*-412"
-                                                         "l-*-410"
-                                                         "l-*-408"
-                                                         "l-*-406"
-                                                         "l-*-404"
-                                                         "l-*-402"
-                                                         "l-*-400"
-                                                         "l-*-399"
-                                                         "l-*-397"
-                                                         "l-*-394"
-                                                         "l-*-393"
-                                                         "l-*-392"
-                                                         "l-*-390"
-                                                         "l-*-389"
-                                                         "l-*-387"
-                                                         "l-*-385"
-                                                         "l-*-383"
-                                                         "l-*-381"
-                                                         "l-*-379"
-                                                         "l-*-377"
-                                                         "l-*-375"
-                                                         "l-*-373"
-                                                         "l-*-370"
-                                                         "l-*-368"
-                                                         "l-*-367"
-                                                         "l-*-365"
-                                                         "l-*-363"
-                                                         "l-*-361"
-                                                         "l-*-359"
-                                                         "l-*-358"
-                                                         "l-*-357"
-                                                         "l-*-356"
-                                                         "l-*-354"
-                                                         "l-*-353"
-                                                         "l-*-350"
-                                                         "l-*-348"
-                                                         "l-*-346"
-                                                         "l-*-344"
-                                                         "l-*-342"
-                                                         "l-*-340"
-                                                         "l-*-338"
-                                                         "l-*-337"
-                                                         "l-*-336"
-                                                         "l-*-334"
-                                                         "l-*-332"
-                                                         "l-*-331"
-                                                         "l-*-328"
-                                                         "l-*-327"
-                                                         "l-*-325"
-                                                         "l-*-323"
-                                                         "l-*-321"
-                                                         "l-*-319"
-                                                         "l-*-317"
-                                                         "l-*-315"
-                                                         "l-*-313"
-                                                         "l-*-311"
-                                                         "l-*-309"
-                                                         "l-*-306"
-                                                         "l-*-304"
-                                                         "l-*-302"
-                                                         "l-*-300"
-                                                         "l-*-298"
-                                                         "l-*-296"
-                                                         "l-*-294"
-                                                         "l-*-292"
-                                                         "l-*-290"
-                                                         "l-*-288"
-                                                         "l-*-286"
-                                                         "l-*-284"
-                                                         "l-*-282"
-                                                         "l-*-280"
-                                                         "l-*-278"
-                                                         "l-*-276"
-                                                         "l-*-274"
-                                                         "l-*-272"
-                                                         "l-*-270"
-                                                         "l-*-268"
-                                                         "l-*-266"
-                                                         "l-*-264"
-                                                         "l-*-262"
-                                                         "l-*-260"
-                                                         "l-*-258"
-                                                         "l-*-256"
-                                                         "l-*-255"
-                                                         "l-*-254"
-                                                         "l-*-253"
-                                                         "l-*-252"
-                                                         "l-*-250"
-                                                         "l-*-248"
-                                                         "l-*-246"
-                                                         "l-*-243"
-                                                         "l-*-241"
-                                                         "l-*-239"
-                                                         "l-*-237"
-                                                         "l-*-235"
-                                                         "l-*-233"
-                                                         "l-*-231"
-                                                         "l-*-229"
-                                                         "l-*-227"
-                                                         "l-*-225"
-                                                         "l-*-223"
-                                                         "l-*-221"
-                                                         "l-*-219"
-                                                         "l-*-217"
-                                                         "l-*-215"
-                                                         "l-*-213"
-                                                         "l-*-211"
-                                                         "l-*-209"))
-                                                      #(ribcage
-                                                        (define-structure
-                                                          
define-expansion-accessors
-                                                          
define-expansion-constructors)
-                                                        ((top) (top) (top))
-                                                        ("l-*-47"
-                                                         "l-*-46"
-                                                         "l-*-45")))
-                                                     (hygiene guile))
-                                                  head-8878)))
+                                      (lambda () (gen-syntax src y r maps 
ellipsis? mod))
+                                      (lambda (y maps)
+                                        (call-with-values
+                                          (lambda () (k maps))
+                                          (lambda (x maps) (values (gen-append 
x y) maps)))))))))
+                            tmp-1)
+                     (let ((tmp-1 ($sc-dispatch tmp '(any . any))))
+                       (if tmp-1
+                         (apply (lambda (x y)
+                                  (call-with-values
+                                    (lambda () (gen-syntax src x r maps 
ellipsis? mod))
+                                    (lambda (x maps)
                                       (call-with-values
-                                        (lambda ()
-                                          (syntax-type-4296
-                                            e-9069
-                                            r-8489
-                                            w-8490
-                                            (let ((props-9079
-                                                    (source-properties
-                                                      (if (if (vector? e-9069)
-                                                            (if (= 
(vector-length
-                                                                     e-9069)
-                                                                   4)
-                                                              (eq? (vector-ref
-                                                                     e-9069
-                                                                     0)
-                                                                   
'syntax-object)
-                                                              #f)
-                                                            #f)
-                                                        (vector-ref e-9069 1)
-                                                        e-9069))))
-                                              (if (pair? props-9079)
-                                                props-9079
-                                                #f))
-                                            #f
-                                            mod-8492
-                                            #f))
-                                        (lambda (type-9102
-                                                 value-9103
-                                                 form-9104
-                                                 e-9105
-                                                 w-9106
-                                                 s-9107
-                                                 mod-9108)
-                                          (expand-expr-4298
-                                            type-9102
-                                            value-9103
-                                            form-9104
-                                            e-9105
-                                            r-8489
-                                            w-9106
-                                            s-9107
-                                            mod-9108)))))
-                                  (arg-exps-9062
-                                    (map (lambda (e-9112)
-                                           (call-with-values
-                                             (lambda ()
-                                               (syntax-type-4296
-                                                 e-9112
-                                                 r-8489
-                                                 w-8490
-                                                 (let ((props-9127
-                                                         (source-properties
-                                                           (if (if (vector?
-                                                                     e-9112)
-                                                                 (if (= 
(vector-length
-                                                                          
e-9112)
-                                                                        4)
-                                                                   (eq? 
(vector-ref
-                                                                          
e-9112
-                                                                          0)
-                                                                        
'syntax-object)
-                                                                   #f)
-                                                                 #f)
-                                                             (vector-ref
-                                                               e-9112
-                                                               1)
-                                                             e-9112))))
-                                                   (if (pair? props-9127)
-                                                     props-9127
-                                                     #f))
-                                                 #f
-                                                 mod-8492
-                                                 #f))
-                                             (lambda (type-9160
-                                                      value-9161
-                                                      form-9162
-                                                      e-9163
-                                                      w-9164
-                                                      s-9165
-                                                      mod-9166)
-                                               (expand-expr-4298
-                                                 type-9160
-                                                 value-9161
-                                                 form-9162
-                                                 e-9163
-                                                 r-8489
-                                                 w-9164
-                                                 s-9165
-                                                 mod-9166))))
-                                         (append tail-8879 (list val-8880)))))
-                              (make-struct/no-tail
-                                (vector-ref %expanded-vtables 11)
-                                s-8491
-                                fun-exp-9061
-                                arg-exps-9062))))))
-                    tmp-8874)
-                  (syntax-violation
-                    'set!
-                    "bad set!"
-                    (wrap-4290
-                      (begin
-                        (if (if s-8491
-                              (supports-source-properties? e-8488)
-                              #f)
-                          (set-source-properties! e-8488 s-8491))
-                        e-8488)
-                      w-8490
-                      mod-8492))))))))
-      (module-define!
-        (current-module)
-        '@
-        (make-syntax-transformer
-          '@
-          'module-ref
-          (lambda (e-9208 r-9209 w-9210)
-            (let ((tmp-9212
-                    ($sc-dispatch e-9208 '(_ each-any any))))
-              (if (if tmp-9212
-                    (@apply
-                      (lambda (mod-9215 id-9216)
-                        (if (and-map id?-4261 mod-9215)
-                          (if (symbol? id-9216)
-                            #t
-                            (if (if (vector? id-9216)
-                                  (if (= (vector-length id-9216) 4)
-                                    (eq? (vector-ref id-9216 0) 'syntax-object)
-                                    #f)
-                                  #f)
-                              (symbol? (vector-ref id-9216 1))
-                              #f))
-                          #f))
-                      tmp-9212)
-                    #f)
-                (@apply
-                  (lambda (mod-9256 id-9257)
-                    (values
-                      (syntax->datum id-9257)
-                      r-9209
-                      w-9210
-                      #f
-                      (syntax->datum
-                        (cons '#(syntax-object
-                                 public
-                                 ((top)
-                                  #(ribcage
-                                    #(mod id)
-                                    #((top) (top))
-                                    #("l-*-3566" "l-*-3567"))
-                                  #(ribcage () () ())
-                                  #(ribcage
-                                    #(e r w)
-                                    #((top) (top) (top))
-                                    #("l-*-3554" "l-*-3555" "l-*-3556"))
-                                  #(ribcage
-                                    (lambda-var-list
-                                      gen-var
-                                      strip
-                                      expand-lambda-case
-                                      lambda*-formals
-                                      expand-simple-lambda
-                                      lambda-formals
-                                      ellipsis?
-                                      expand-void
-                                      eval-local-transformer
-                                      expand-local-syntax
-                                      expand-body
-                                      expand-macro
-                                      expand-application
-                                      expand-expr
-                                      expand
-                                      syntax-type
-                                      parse-when-list
-                                      expand-install-global
-                                      expand-top-sequence
-                                      expand-sequence
-                                      source-wrap
-                                      wrap
-                                      bound-id-member?
-                                      distinct-bound-ids?
-                                      valid-bound-ids?
-                                      bound-id=?
-                                      free-id=?
-                                      with-transformer-environment
-                                      transformer-environment
-                                      resolve-identifier
-                                      locally-bound-identifiers
-                                      id-var-name
-                                      same-marks?
-                                      join-marks
-                                      join-wraps
-                                      smart-append
-                                      make-binding-wrap
-                                      extend-ribcage!
-                                      make-empty-ribcage
-                                      new-mark
-                                      anti-mark
-                                      the-anti-mark
-                                      top-marked?
-                                      top-wrap
-                                      empty-wrap
-                                      set-ribcage-labels!
-                                      set-ribcage-marks!
-                                      set-ribcage-symnames!
-                                      ribcage-labels
-                                      ribcage-marks
-                                      ribcage-symnames
-                                      ribcage?
-                                      make-ribcage
-                                      gen-labels
-                                      gen-label
-                                      make-rename
-                                      rename-marks
-                                      rename-new
-                                      rename-old
-                                      subst-rename?
-                                      wrap-subst
-                                      wrap-marks
-                                      make-wrap
-                                      id-sym-name&marks
-                                      id-sym-name
-                                      id?
-                                      nonsymbol-id?
-                                      global-extend
-                                      lookup
-                                      macros-only-env
-                                      extend-var-env
-                                      extend-env
-                                      null-env
-                                      binding-value
-                                      binding-type
-                                      make-binding
-                                      arg-check
-                                      source-annotation
-                                      no-source
-                                      set-syntax-object-module!
-                                      set-syntax-object-wrap!
-                                      set-syntax-object-expression!
-                                      syntax-object-module
-                                      syntax-object-wrap
-                                      syntax-object-expression
-                                      syntax-object?
-                                      make-syntax-object
-                                      build-lexical-var
-                                      build-letrec
-                                      build-named-let
-                                      build-let
-                                      build-sequence
-                                      build-data
-                                      build-primref
-                                      build-lambda-case
-                                      build-case-lambda
-                                      build-simple-lambda
-                                      build-global-definition
-                                      build-global-assignment
-                                      build-global-reference
-                                      analyze-variable
-                                      build-lexical-assignment
-                                      build-lexical-reference
-                                      build-dynlet
-                                      build-conditional
-                                      build-application
-                                      build-void
-                                      maybe-name-value!
-                                      decorate-source
-                                      get-global-definition-hook
-                                      put-global-definition-hook
-                                      session-id
-                                      local-eval-hook
-                                      top-level-eval-hook
-                                      fx<
-                                      fx=
-                                      fx-
-                                      fx+
-                                      set-lambda-meta!
-                                      lambda-meta
-                                      lambda?
-                                      make-dynlet
-                                      make-letrec
-                                      make-let
-                                      make-lambda-case
-                                      make-lambda
-                                      make-sequence
-                                      make-application
-                                      make-conditional
-                                      make-toplevel-define
-                                      make-toplevel-set
-                                      make-toplevel-ref
-                                      make-module-set
-                                      make-module-ref
-                                      make-lexical-set
-                                      make-lexical-ref
-                                      make-primitive-ref
-                                      make-const
-                                      make-void)
-                                    ((top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top)
-                                     (top))
-                                    ("l-*-476"
-                                     "l-*-474"
-                                     "l-*-472"
-                                     "l-*-470"
-                                     "l-*-468"
-                                     "l-*-466"
-                                     "l-*-464"
-                                     "l-*-462"
-                                     "l-*-460"
-                                     "l-*-458"
-                                     "l-*-456"
-                                     "l-*-454"
-                                     "l-*-452"
-                                     "l-*-450"
-                                     "l-*-448"
-                                     "l-*-446"
-                                     "l-*-444"
-                                     "l-*-442"
-                                     "l-*-440"
-                                     "l-*-438"
-                                     "l-*-436"
-                                     "l-*-434"
-                                     "l-*-432"
-                                     "l-*-430"
-                                     "l-*-428"
-                                     "l-*-426"
-                                     "l-*-424"
-                                     "l-*-422"
-                                     "l-*-420"
-                                     "l-*-418"
-                                     "l-*-416"
-                                     "l-*-414"
-                                     "l-*-412"
-                                     "l-*-410"
-                                     "l-*-408"
-                                     "l-*-406"
-                                     "l-*-404"
-                                     "l-*-402"
-                                     "l-*-400"
-                                     "l-*-399"
-                                     "l-*-397"
-                                     "l-*-394"
-                                     "l-*-393"
-                                     "l-*-392"
-                                     "l-*-390"
-                                     "l-*-389"
-                                     "l-*-387"
-                                     "l-*-385"
-                                     "l-*-383"
-                                     "l-*-381"
-                                     "l-*-379"
-                                     "l-*-377"
-                                     "l-*-375"
-                                     "l-*-373"
-                                     "l-*-370"
-                                     "l-*-368"
-                                     "l-*-367"
-                                     "l-*-365"
-                                     "l-*-363"
-                                     "l-*-361"
-                                     "l-*-359"
-                                     "l-*-358"
-                                     "l-*-357"
-                                     "l-*-356"
-                                     "l-*-354"
-                                     "l-*-353"
-                                     "l-*-350"
-                                     "l-*-348"
-                                     "l-*-346"
-                                     "l-*-344"
-                                     "l-*-342"
-                                     "l-*-340"
-                                     "l-*-338"
-                                     "l-*-337"
-                                     "l-*-336"
-                                     "l-*-334"
-                                     "l-*-332"
-                                     "l-*-331"
-                                     "l-*-328"
-                                     "l-*-327"
-                                     "l-*-325"
-                                     "l-*-323"
-                                     "l-*-321"
-                                     "l-*-319"
-                                     "l-*-317"
-                                     "l-*-315"
-                                     "l-*-313"
-                                     "l-*-311"
-                                     "l-*-309"
-                                     "l-*-306"
-                                     "l-*-304"
-                                     "l-*-302"
-                                     "l-*-300"
-                                     "l-*-298"
-                                     "l-*-296"
-                                     "l-*-294"
-                                     "l-*-292"
-                                     "l-*-290"
-                                     "l-*-288"
-                                     "l-*-286"
-                                     "l-*-284"
-                                     "l-*-282"
-                                     "l-*-280"
-                                     "l-*-278"
-                                     "l-*-276"
-                                     "l-*-274"
-                                     "l-*-272"
-                                     "l-*-270"
-                                     "l-*-268"
-                                     "l-*-266"
-                                     "l-*-264"
-                                     "l-*-262"
-                                     "l-*-260"
-                                     "l-*-258"
-                                     "l-*-256"
-                                     "l-*-255"
-                                     "l-*-254"
-                                     "l-*-253"
-                                     "l-*-252"
-                                     "l-*-250"
-                                     "l-*-248"
-                                     "l-*-246"
-                                     "l-*-243"
-                                     "l-*-241"
-                                     "l-*-239"
-                                     "l-*-237"
-                                     "l-*-235"
-                                     "l-*-233"
-                                     "l-*-231"
-                                     "l-*-229"
-                                     "l-*-227"
-                                     "l-*-225"
-                                     "l-*-223"
-                                     "l-*-221"
-                                     "l-*-219"
-                                     "l-*-217"
-                                     "l-*-215"
-                                     "l-*-213"
-                                     "l-*-211"
-                                     "l-*-209"))
-                                  #(ribcage
-                                    (define-structure
-                                      define-expansion-accessors
-                                      define-expansion-constructors)
-                                    ((top) (top) (top))
-                                    ("l-*-47" "l-*-46" "l-*-45")))
-                                 (hygiene guile))
-                              mod-9256))))
-                  tmp-9212)
-                (syntax-violation
-                  #f
-                  "source expression failed to match any pattern"
-                  e-9208))))))
-      (global-extend-4259
-        'module-ref
-        '@@
-        (lambda (e-9368 r-9369 w-9370)
-          (letrec*
-            ((remodulate-9371
-               (lambda (x-9433 mod-9434)
-                 (if (pair? x-9433)
-                   (cons (remodulate-9371 (car x-9433) mod-9434)
-                         (remodulate-9371 (cdr x-9433) mod-9434))
-                   (if (if (vector? x-9433)
-                         (if (= (vector-length x-9433) 4)
-                           (eq? (vector-ref x-9433 0) 'syntax-object)
-                           #f)
-                         #f)
-                     (let ((expression-9448
-                             (remodulate-9371 (vector-ref x-9433 1) mod-9434))
-                           (wrap-9449 (vector-ref x-9433 2)))
-                       (vector
-                         'syntax-object
-                         expression-9448
-                         wrap-9449
-                         mod-9434))
-                     (if (vector? x-9433)
-                       (let ((n-9457 (vector-length x-9433)))
-                         (let ((v-9458 (make-vector n-9457)))
-                           (letrec*
-                             ((loop-9459
-                                (lambda (i-9506)
-                                  (if (= i-9506 n-9457)
-                                    v-9458
-                                    (begin
-                                      (vector-set!
-                                        v-9458
-                                        i-9506
-                                        (remodulate-9371
-                                          (vector-ref x-9433 i-9506)
-                                          mod-9434))
-                                      (loop-9459 (#{1+}# i-9506)))))))
-                             (loop-9459 0))))
-                       x-9433))))))
-            (let ((tmp-9373
-                    ($sc-dispatch e-9368 '(_ each-any any))))
-              (if (if tmp-9373
-                    (@apply
-                      (lambda (mod-9377 exp-9378)
-                        (and-map id?-4261 mod-9377))
-                      tmp-9373)
-                    #f)
-                (@apply
-                  (lambda (mod-9394 exp-9395)
-                    (let ((mod-9396
-                            (syntax->datum
-                              (cons '#(syntax-object
-                                       private
-                                       ((top)
-                                        #(ribcage
-                                          #(mod exp)
-                                          #((top) (top))
-                                          #("l-*-3604" "l-*-3605"))
-                                        #(ribcage
-                                          (remodulate)
-                                          ((top))
-                                          ("l-*-3577"))
-                                        #(ribcage
-                                          #(e r w)
-                                          #((top) (top) (top))
-                                          #("l-*-3574" "l-*-3575" "l-*-3576"))
-                                        #(ribcage
-                                          (lambda-var-list
-                                            gen-var
-                                            strip
-                                            expand-lambda-case
-                                            lambda*-formals
-                                            expand-simple-lambda
-                                            lambda-formals
-                                            ellipsis?
-                                            expand-void
-                                            eval-local-transformer
-                                            expand-local-syntax
-                                            expand-body
-                                            expand-macro
-                                            expand-application
-                                            expand-expr
-                                            expand
-                                            syntax-type
-                                            parse-when-list
-                                            expand-install-global
-                                            expand-top-sequence
-                                            expand-sequence
-                                            source-wrap
-                                            wrap
-                                            bound-id-member?
-                                            distinct-bound-ids?
-                                            valid-bound-ids?
-                                            bound-id=?
-                                            free-id=?
-                                            with-transformer-environment
-                                            transformer-environment
-                                            resolve-identifier
-                                            locally-bound-identifiers
-                                            id-var-name
-                                            same-marks?
-                                            join-marks
-                                            join-wraps
-                                            smart-append
-                                            make-binding-wrap
-                                            extend-ribcage!
-                                            make-empty-ribcage
-                                            new-mark
-                                            anti-mark
-                                            the-anti-mark
-                                            top-marked?
-                                            top-wrap
-                                            empty-wrap
-                                            set-ribcage-labels!
-                                            set-ribcage-marks!
-                                            set-ribcage-symnames!
-                                            ribcage-labels
-                                            ribcage-marks
-                                            ribcage-symnames
-                                            ribcage?
-                                            make-ribcage
-                                            gen-labels
-                                            gen-label
-                                            make-rename
-                                            rename-marks
-                                            rename-new
-                                            rename-old
-                                            subst-rename?
-                                            wrap-subst
-                                            wrap-marks
-                                            make-wrap
-                                            id-sym-name&marks
-                                            id-sym-name
-                                            id?
-                                            nonsymbol-id?
-                                            global-extend
-                                            lookup
-                                            macros-only-env
-                                            extend-var-env
-                                            extend-env
-                                            null-env
-                                            binding-value
-                                            binding-type
-                                            make-binding
-                                            arg-check
-                                            source-annotation
-                                            no-source
-                                            set-syntax-object-module!
-                                            set-syntax-object-wrap!
-                                            set-syntax-object-expression!
-                                            syntax-object-module
-                                            syntax-object-wrap
-                                            syntax-object-expression
-                                            syntax-object?
-                                            make-syntax-object
-                                            build-lexical-var
-                                            build-letrec
-                                            build-named-let
-                                            build-let
-                                            build-sequence
-                                            build-data
-                                            build-primref
-                                            build-lambda-case
-                                            build-case-lambda
-                                            build-simple-lambda
-                                            build-global-definition
-                                            build-global-assignment
-                                            build-global-reference
-                                            analyze-variable
-                                            build-lexical-assignment
-                                            build-lexical-reference
-                                            build-dynlet
-                                            build-conditional
-                                            build-application
-                                            build-void
-                                            maybe-name-value!
-                                            decorate-source
-                                            get-global-definition-hook
-                                            put-global-definition-hook
-                                            session-id
-                                            local-eval-hook
-                                            top-level-eval-hook
-                                            fx<
-                                            fx=
-                                            fx-
-                                            fx+
-                                            set-lambda-meta!
-                                            lambda-meta
-                                            lambda?
-                                            make-dynlet
-                                            make-letrec
-                                            make-let
-                                            make-lambda-case
-                                            make-lambda
-                                            make-sequence
-                                            make-application
-                                            make-conditional
-                                            make-toplevel-define
-                                            make-toplevel-set
-                                            make-toplevel-ref
-                                            make-module-set
-                                            make-module-ref
-                                            make-lexical-set
-                                            make-lexical-ref
-                                            make-primitive-ref
-                                            make-const
-                                            make-void)
-                                          ((top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top)
-                                           (top))
-                                          ("l-*-476"
-                                           "l-*-474"
-                                           "l-*-472"
-                                           "l-*-470"
-                                           "l-*-468"
-                                           "l-*-466"
-                                           "l-*-464"
-                                           "l-*-462"
-                                           "l-*-460"
-                                           "l-*-458"
-                                           "l-*-456"
-                                           "l-*-454"
-                                           "l-*-452"
-                                           "l-*-450"
-                                           "l-*-448"
-                                           "l-*-446"
-                                           "l-*-444"
-                                           "l-*-442"
-                                           "l-*-440"
-                                           "l-*-438"
-                                           "l-*-436"
-                                           "l-*-434"
-                                           "l-*-432"
-                                           "l-*-430"
-                                           "l-*-428"
-                                           "l-*-426"
-                                           "l-*-424"
-                                           "l-*-422"
-                                           "l-*-420"
-                                           "l-*-418"
-                                           "l-*-416"
-                                           "l-*-414"
-                                           "l-*-412"
-                                           "l-*-410"
-                                           "l-*-408"
-                                           "l-*-406"
-                                           "l-*-404"
-                                           "l-*-402"
-                                           "l-*-400"
-                                           "l-*-399"
-                                           "l-*-397"
-                                           "l-*-394"
-                                           "l-*-393"
-                                           "l-*-392"
-                                           "l-*-390"
-                                           "l-*-389"
-                                           "l-*-387"
-                                           "l-*-385"
-                                           "l-*-383"
-                                           "l-*-381"
-                                           "l-*-379"
-                                           "l-*-377"
-                                           "l-*-375"
-                                           "l-*-373"
-                                           "l-*-370"
-                                           "l-*-368"
-                                           "l-*-367"
-                                           "l-*-365"
-                                           "l-*-363"
-                                           "l-*-361"
-                                           "l-*-359"
-                                           "l-*-358"
-                                           "l-*-357"
-                                           "l-*-356"
-                                           "l-*-354"
-                                           "l-*-353"
-                                           "l-*-350"
-                                           "l-*-348"
-                                           "l-*-346"
-                                           "l-*-344"
-                                           "l-*-342"
-                                           "l-*-340"
-                                           "l-*-338"
-                                           "l-*-337"
-                                           "l-*-336"
-                                           "l-*-334"
-                                           "l-*-332"
-                                           "l-*-331"
-                                           "l-*-328"
-                                           "l-*-327"
-                                           "l-*-325"
-                                           "l-*-323"
-                                           "l-*-321"
-                                           "l-*-319"
-                                           "l-*-317"
-                                           "l-*-315"
-                                           "l-*-313"
-                                           "l-*-311"
-                                           "l-*-309"
-                                           "l-*-306"
-                                           "l-*-304"
-                                           "l-*-302"
-                                           "l-*-300"
-                                           "l-*-298"
-                                           "l-*-296"
-                                           "l-*-294"
-                                           "l-*-292"
-                                           "l-*-290"
-                                           "l-*-288"
-                                           "l-*-286"
-                                           "l-*-284"
-                                           "l-*-282"
-                                           "l-*-280"
-                                           "l-*-278"
-                                           "l-*-276"
-                                           "l-*-274"
-                                           "l-*-272"
-                                           "l-*-270"
-                                           "l-*-268"
-                                           "l-*-266"
-                                           "l-*-264"
-                                           "l-*-262"
-                                           "l-*-260"
-                                           "l-*-258"
-                                           "l-*-256"
-                                           "l-*-255"
-                                           "l-*-254"
-                                           "l-*-253"
-                                           "l-*-252"
-                                           "l-*-250"
-                                           "l-*-248"
-                                           "l-*-246"
-                                           "l-*-243"
-                                           "l-*-241"
-                                           "l-*-239"
-                                           "l-*-237"
-                                           "l-*-235"
-                                           "l-*-233"
-                                           "l-*-231"
-                                           "l-*-229"
-                                           "l-*-227"
-                                           "l-*-225"
-                                           "l-*-223"
-                                           "l-*-221"
-                                           "l-*-219"
-                                           "l-*-217"
-                                           "l-*-215"
-                                           "l-*-213"
-                                           "l-*-211"
-                                           "l-*-209"))
-                                        #(ribcage
-                                          (define-structure
-                                            define-expansion-accessors
-                                            define-expansion-constructors)
-                                          ((top) (top) (top))
-                                          ("l-*-47" "l-*-46" "l-*-45")))
-                                       (hygiene guile))
-                                    mod-9394))))
-                      (values
-                        (remodulate-9371 exp-9395 mod-9396)
-                        r-9369
-                        w-9370
-                        (let ((props-9404
-                                (source-properties
-                                  (if (if (vector? exp-9395)
-                                        (if (= (vector-length exp-9395) 4)
-                                          (eq? (vector-ref exp-9395 0)
-                                               'syntax-object)
-                                          #f)
-                                        #f)
-                                    (vector-ref exp-9395 1)
-                                    exp-9395))))
-                          (if (pair? props-9404) props-9404 #f))
-                        mod-9396)))
-                  tmp-9373)
-                (syntax-violation
-                  #f
-                  "source expression failed to match any pattern"
-                  e-9368))))))
-      (global-extend-4259
-        'core
-        'if
-        (lambda (e-9750 r-9751 w-9752 s-9753 mod-9754)
-          (let ((tmp-9756 ($sc-dispatch e-9750 '(_ any any))))
-            (if tmp-9756
-              (@apply
-                (lambda (test-9760 then-9761)
-                  (let ((test-exp-9766
-                          (call-with-values
-                            (lambda ()
-                              (syntax-type-4296
-                                test-9760
-                                r-9751
-                                w-9752
-                                (let ((props-9788
-                                        (source-properties
-                                          (if (if (vector? test-9760)
-                                                (if (= (vector-length
-                                                         test-9760)
-                                                       4)
-                                                  (eq? (vector-ref test-9760 0)
-                                                       'syntax-object)
-                                                  #f)
-                                                #f)
-                                            (vector-ref test-9760 1)
-                                            test-9760))))
-                                  (if (pair? props-9788) props-9788 #f))
-                                #f
-                                mod-9754
-                                #f))
-                            (lambda (type-9821
-                                     value-9822
-                                     form-9823
-                                     e-9824
-                                     w-9825
-                                     s-9826
-                                     mod-9827)
-                              (expand-expr-4298
-                                type-9821
-                                value-9822
-                                form-9823
-                                e-9824
-                                r-9751
-                                w-9825
-                                s-9826
-                                mod-9827))))
-                        (then-exp-9767
-                          (call-with-values
-                            (lambda ()
-                              (syntax-type-4296
-                                then-9761
-                                r-9751
-                                w-9752
-                                (let ((props-9845
-                                        (source-properties
-                                          (if (if (vector? then-9761)
-                                                (if (= (vector-length
-                                                         then-9761)
-                                                       4)
-                                                  (eq? (vector-ref then-9761 0)
-                                                       'syntax-object)
-                                                  #f)
-                                                #f)
-                                            (vector-ref then-9761 1)
-                                            then-9761))))
-                                  (if (pair? props-9845) props-9845 #f))
-                                #f
-                                mod-9754
-                                #f))
-                            (lambda (type-9878
-                                     value-9879
-                                     form-9880
-                                     e-9881
-                                     w-9882
-                                     s-9883
-                                     mod-9884)
-                              (expand-expr-4298
-                                type-9878
-                                value-9879
-                                form-9880
-                                e-9881
-                                r-9751
-                                w-9882
-                                s-9883
-                                mod-9884))))
-                        (else-exp-9768
-                          (make-struct/no-tail
-                            (vector-ref %expanded-vtables 0)
-                            #f)))
-                    (make-struct/no-tail
-                      (vector-ref %expanded-vtables 10)
-                      s-9753
-                      test-exp-9766
-                      then-exp-9767
-                      else-exp-9768)))
-                tmp-9756)
-              (let ((tmp-9893 ($sc-dispatch e-9750 '(_ any any any))))
-                (if tmp-9893
-                  (@apply
-                    (lambda (test-9897 then-9898 else-9899)
-                      (let ((test-exp-9904
-                              (call-with-values
-                                (lambda ()
-                                  (syntax-type-4296
-                                    test-9897
-                                    r-9751
-                                    w-9752
-                                    (let ((props-9926
-                                            (source-properties
-                                              (if (if (vector? test-9897)
-                                                    (if (= (vector-length
-                                                             test-9897)
-                                                           4)
-                                                      (eq? (vector-ref
-                                                             test-9897
-                                                             0)
-                                                           'syntax-object)
-                                                      #f)
-                                                    #f)
-                                                (vector-ref test-9897 1)
-                                                test-9897))))
-                                      (if (pair? props-9926) props-9926 #f))
-                                    #f
-                                    mod-9754
-                                    #f))
-                                (lambda (type-9959
-                                         value-9960
-                                         form-9961
-                                         e-9962
-                                         w-9963
-                                         s-9964
-                                         mod-9965)
-                                  (expand-expr-4298
-                                    type-9959
-                                    value-9960
-                                    form-9961
-                                    e-9962
-                                    r-9751
-                                    w-9963
-                                    s-9964
-                                    mod-9965))))
-                            (then-exp-9905
-                              (call-with-values
-                                (lambda ()
-                                  (syntax-type-4296
-                                    then-9898
-                                    r-9751
-                                    w-9752
-                                    (let ((props-9983
-                                            (source-properties
-                                              (if (if (vector? then-9898)
-                                                    (if (= (vector-length
-                                                             then-9898)
-                                                           4)
-                                                      (eq? (vector-ref
-                                                             then-9898
-                                                             0)
-                                                           'syntax-object)
-                                                      #f)
-                                                    #f)
-                                                (vector-ref then-9898 1)
-                                                then-9898))))
-                                      (if (pair? props-9983) props-9983 #f))
-                                    #f
-                                    mod-9754
-                                    #f))
-                                (lambda (type-10016
-                                         value-10017
-                                         form-10018
-                                         e-10019
-                                         w-10020
-                                         s-10021
-                                         mod-10022)
-                                  (expand-expr-4298
-                                    type-10016
-                                    value-10017
-                                    form-10018
-                                    e-10019
-                                    r-9751
-                                    w-10020
-                                    s-10021
-                                    mod-10022))))
-                            (else-exp-9906
-                              (call-with-values
-                                (lambda ()
-                                  (syntax-type-4296
-                                    else-9899
-                                    r-9751
-                                    w-9752
-                                    (let ((props-10040
-                                            (source-properties
-                                              (if (if (vector? else-9899)
-                                                    (if (= (vector-length
-                                                             else-9899)
-                                                           4)
-                                                      (eq? (vector-ref
-                                                             else-9899
-                                                             0)
-                                                           'syntax-object)
-                                                      #f)
-                                                    #f)
-                                                (vector-ref else-9899 1)
-                                                else-9899))))
-                                      (if (pair? props-10040) props-10040 #f))
-                                    #f
-                                    mod-9754
-                                    #f))
-                                (lambda (type-10073
-                                         value-10074
-                                         form-10075
-                                         e-10076
-                                         w-10077
-                                         s-10078
-                                         mod-10079)
-                                  (expand-expr-4298
-                                    type-10073
-                                    value-10074
-                                    form-10075
-                                    e-10076
-                                    r-9751
-                                    w-10077
-                                    s-10078
-                                    mod-10079)))))
-                        (make-struct/no-tail
-                          (vector-ref %expanded-vtables 10)
-                          s-9753
-                          test-exp-9904
-                          then-exp-9905
-                          else-exp-9906)))
-                    tmp-9893)
-                  (syntax-violation
-                    #f
-                    "source expression failed to match any pattern"
-                    e-9750)))))))
-      (module-define!
-        (current-module)
-        'with-fluids
-        (make-syntax-transformer
-          'with-fluids
-          'core
-          (lambda (e-10102 r-10103 w-10104 s-10105 mod-10106)
-            (let ((tmp-10108
-                    ($sc-dispatch
-                      e-10102
-                      '(_ #(each (any any)) any . each-any))))
-              (if tmp-10108
-                (@apply
-                  (lambda (fluid-10111 val-10112 b-10113 b*-10114)
-                    (let ((fluids-10117
-                            (map (lambda (x-10125)
-                                   (call-with-values
-                                     (lambda ()
-                                       (syntax-type-4296
-                                         x-10125
-                                         r-10103
-                                         w-10104
-                                         (let ((props-10140
-                                                 (source-properties
-                                                   (if (if (vector? x-10125)
-                                                         (if (= (vector-length
-                                                                  x-10125)
-                                                                4)
-                                                           (eq? (vector-ref
-                                                                  x-10125
-                                                                  0)
-                                                                'syntax-object)
-                                                           #f)
-                                                         #f)
-                                                     (vector-ref x-10125 1)
-                                                     x-10125))))
-                                           (if (pair? props-10140)
-                                             props-10140
-                                             #f))
-                                         #f
-                                         mod-10106
-                                         #f))
-                                     (lambda (type-10173
-                                              value-10174
-                                              form-10175
-                                              e-10176
-                                              w-10177
-                                              s-10178
-                                              mod-10179)
-                                       (expand-expr-4298
-                                         type-10173
-                                         value-10174
-                                         form-10175
-                                         e-10176
-                                         r-10103
-                                         w-10177
-                                         s-10178
-                                         mod-10179))))
-                                 fluid-10111))
-                          (vals-10118
-                            (map (lambda (x-10183)
-                                   (call-with-values
-                                     (lambda ()
-                                       (syntax-type-4296
-                                         x-10183
-                                         r-10103
-                                         w-10104
-                                         (let ((props-10198
-                                                 (source-properties
-                                                   (if (if (vector? x-10183)
-                                                         (if (= (vector-length
-                                                                  x-10183)
-                                                                4)
-                                                           (eq? (vector-ref
-                                                                  x-10183
-                                                                  0)
-                                                                'syntax-object)
-                                                           #f)
-                                                         #f)
-                                                     (vector-ref x-10183 1)
-                                                     x-10183))))
-                                           (if (pair? props-10198)
-                                             props-10198
-                                             #f))
-                                         #f
-                                         mod-10106
-                                         #f))
-                                     (lambda (type-10231
-                                              value-10232
-                                              form-10233
-                                              e-10234
-                                              w-10235
-                                              s-10236
-                                              mod-10237)
-                                       (expand-expr-4298
-                                         type-10231
-                                         value-10232
-                                         form-10233
-                                         e-10234
-                                         r-10103
-                                         w-10235
-                                         s-10236
-                                         mod-10237))))
-                                 val-10112))
-                          (body-10119
-                            (expand-body-4301
-                              (cons b-10113 b*-10114)
-                              (wrap-4290
-                                (begin
-                                  (if (if s-10105
-                                        (supports-source-properties? e-10102)
-                                        #f)
-                                    (set-source-properties! e-10102 s-10105))
-                                  e-10102)
-                                w-10104
-                                mod-10106)
-                              r-10103
-                              w-10104
-                              mod-10106)))
-                      (make-struct/no-tail
-                        (vector-ref %expanded-vtables 17)
-                        s-10105
-                        fluids-10117
-                        vals-10118
-                        body-10119)))
-                  tmp-10108)
-                (syntax-violation
-                  #f
-                  "source expression failed to match any pattern"
-                  e-10102))))))
-      (module-define!
-        (current-module)
-        'begin
-        (make-syntax-transformer 'begin 'begin '()))
-      (module-define!
-        (current-module)
-        'define
-        (make-syntax-transformer 'define 'define '()))
-      (module-define!
-        (current-module)
-        'define-syntax
-        (make-syntax-transformer
-          'define-syntax
-          'define-syntax
-          '()))
-      (module-define!
-        (current-module)
-        'define-syntax-parameter
-        (make-syntax-transformer
-          'define-syntax-parameter
-          'define-syntax-parameter
-          '()))
-      (module-define!
-        (current-module)
-        'eval-when
-        (make-syntax-transformer
-          'eval-when
-          'eval-when
-          '()))
-      (global-extend-4259
-        'core
-        'syntax-case
-        (letrec*
-          ((convert-pattern-10535
-             (lambda (pattern-12018 keys-12019)
-               (letrec*
-                 ((cvt*-12020
-                    (lambda (p*-12644 n-12645 ids-12646)
-                      (if (not (pair? p*-12644))
-                        (cvt-12022 p*-12644 n-12645 ids-12646)
+                                        (lambda () (gen-syntax src y r maps 
ellipsis? mod))
+                                        (lambda (y maps) (values (gen-cons x 
y) maps))))))
+                                tmp-1)
+                         (let ((tmp ($sc-dispatch tmp '#(vector (any . 
each-any)))))
+                           (if tmp
+                             (apply (lambda (e1 e2)
+                                      (call-with-values
+                                        (lambda () (gen-syntax src (cons e1 
e2) r maps ellipsis? mod))
+                                        (lambda (e maps) (values (gen-vector 
e) maps))))
+                                    tmp)
+                             (values (list 'quote e) maps))))))))))))
+       (gen-ref
+         (lambda (src var level maps)
+           (cond ((= level 0) (values var maps))
+                 ((null? maps) (syntax-violation 'syntax "missing ellipsis" 
src))
+                 (else
+                  (call-with-values
+                    (lambda () (gen-ref src var (- level 1) (cdr maps)))
+                    (lambda (outer-var outer-maps)
+                      (let ((b (assq outer-var (car maps))))
+                        (if b
+                          (values (cdr b) maps)
+                          (let ((inner-var (gen-var 'tmp)))
+                            (values
+                              inner-var
+                              (cons (cons (cons outer-var inner-var) (car 
maps)) outer-maps)))))))))))
+       (gen-mappend
+         (lambda (e map-env)
+           (list 'apply '(primitive append) (gen-map e map-env))))
+       (gen-map
+         (lambda (e map-env)
+           (let ((formals (map cdr map-env))
+                 (actuals (map (lambda (x) (list 'ref (car x))) map-env)))
+             (cond ((eq? (car e) 'ref) (car actuals))
+                   ((and-map
+                      (lambda (x) (and (eq? (car x) 'ref) (memq (cadr x) 
formals)))
+                      (cdr e))
+                    (cons 'map
+                          (cons (list 'primitive (car e))
+                                (map (let ((r (map cons formals actuals)))
+                                       (lambda (x) (cdr (assq (cadr x) r))))
+                                     (cdr e)))))
+                   (else (cons 'map (cons (list 'lambda formals e) 
actuals)))))))
+       (gen-cons
+         (lambda (x y)
+           (let ((key (car y)))
+             (cond ((memv key '(quote))
+                    (cond ((eq? (car x) 'quote) (list 'quote (cons (cadr x) 
(cadr y))))
+                          ((eq? (cadr y) '()) (list 'list x))
+                          (else (list 'cons x y))))
+                   ((memv key '(list)) (cons 'list (cons x (cdr y))))
+                   (else (list 'cons x y))))))
+       (gen-append (lambda (x y) (if (equal? y ''()) x (list 'append x y))))
+       (gen-vector
+         (lambda (x)
+           (cond ((eq? (car x) 'list) (cons 'vector (cdr x)))
+                 ((eq? (car x) 'quote) (list 'quote (list->vector (cadr x))))
+                 (else (list 'list->vector x)))))
+       (regen (lambda (x)
+                (let ((key (car x)))
+                  (cond ((memv key '(ref))
+                         (build-lexical-reference 'value #f (cadr x) (cadr x)))
+                        ((memv key '(primitive)) (build-primref #f (cadr x)))
+                        ((memv key '(quote)) (build-data #f (cadr x)))
+                        ((memv key '(lambda))
+                         (if (list? (cadr x))
+                           (build-simple-lambda #f (cadr x) #f (cadr x) '() 
(regen (caddr x)))
+                           (error "how did we get here" x)))
+                        (else
+                         (build-application #f (build-primref #f (car x)) (map 
regen (cdr x)))))))))
+      (lambda (e r w s mod)
+        (let* ((e (source-wrap e w s mod))
+               (tmp e)
+               (tmp ($sc-dispatch tmp '(_ any))))
+          (if tmp
+            (apply (lambda (x)
+                     (call-with-values
+                       (lambda () (gen-syntax e x r '() ellipsis? mod))
+                       (lambda (e maps) (regen e))))
+                   tmp)
+            (syntax-violation 'syntax "bad `syntax' form" e))))))
+  (global-extend
+    'core
+    'lambda
+    (lambda (e r w s mod)
+      (let* ((tmp e) (tmp ($sc-dispatch tmp '(_ any any . each-any))))
+        (if tmp
+          (apply (lambda (args e1 e2)
+                   (call-with-values
+                     (lambda () (lambda-formals args))
+                     (lambda (req opt rest kw)
+                       (let lp ((body (cons e1 e2)) (meta '()))
+                         (let* ((tmp-1 body) (tmp ($sc-dispatch tmp-1 '(any 
any . each-any))))
+                           (if (and tmp
+                                    (apply (lambda (docstring e1 e2) (string? 
(syntax->datum docstring)))
+                                           tmp))
+                             (apply (lambda (docstring e1 e2)
+                                      (lp (cons e1 e2)
+                                          (append meta (list (cons 
'documentation (syntax->datum docstring))))))
+                                    tmp)
+                             (let ((tmp ($sc-dispatch tmp-1 '(#(vector #(each 
(any . any))) any . each-any))))
+                               (if tmp
+                                 (apply (lambda (k v e1 e2)
+                                          (lp (cons e1 e2) (append meta 
(syntax->datum (map cons k v)))))
+                                        tmp)
+                                 (expand-simple-lambda e r w s mod req rest 
meta body)))))))))
+                 tmp)
+          (syntax-violation 'lambda "bad lambda" e)))))
+  (global-extend
+    'core
+    'lambda*
+    (lambda (e r w s mod)
+      (let* ((tmp e) (tmp ($sc-dispatch tmp '(_ any any . each-any))))
+        (if tmp
+          (apply (lambda (args e1 e2)
+                   (call-with-values
+                     (lambda ()
+                       (expand-lambda-case
+                         e
+                         r
+                         w
+                         s
+                         mod
+                         lambda*-formals
+                         (list (cons args (cons e1 e2)))))
+                     (lambda (meta lcase) (build-case-lambda s meta lcase))))
+                 tmp)
+          (syntax-violation 'lambda "bad lambda*" e)))))
+  (global-extend
+    'core
+    'case-lambda
+    (lambda (e r w s mod)
+      (let* ((tmp e)
+             (tmp ($sc-dispatch
+                    tmp
+                    '(_ (any any . each-any) . #(each (any any . each-any))))))
+        (if tmp
+          (apply (lambda (args e1 e2 args* e1* e2*)
+                   (call-with-values
+                     (lambda ()
+                       (expand-lambda-case
+                         e
+                         r
+                         w
+                         s
+                         mod
+                         lambda-formals
+                         (cons (cons args (cons e1 e2))
+                               (map (lambda (tmp-2 tmp-1 tmp) (cons tmp (cons 
tmp-1 tmp-2)))
+                                    e2*
+                                    e1*
+                                    args*))))
+                     (lambda (meta lcase) (build-case-lambda s meta lcase))))
+                 tmp)
+          (syntax-violation 'case-lambda "bad case-lambda" e)))))
+  (global-extend
+    'core
+    'case-lambda*
+    (lambda (e r w s mod)
+      (let* ((tmp e)
+             (tmp ($sc-dispatch
+                    tmp
+                    '(_ (any any . each-any) . #(each (any any . each-any))))))
+        (if tmp
+          (apply (lambda (args e1 e2 args* e1* e2*)
+                   (call-with-values
+                     (lambda ()
+                       (expand-lambda-case
+                         e
+                         r
+                         w
+                         s
+                         mod
+                         lambda*-formals
+                         (cons (cons args (cons e1 e2))
+                               (map (lambda (tmp-2 tmp-1 tmp) (cons tmp (cons 
tmp-1 tmp-2)))
+                                    e2*
+                                    e1*
+                                    args*))))
+                     (lambda (meta lcase) (build-case-lambda s meta lcase))))
+                 tmp)
+          (syntax-violation 'case-lambda "bad case-lambda*" e)))))
+  (global-extend
+    'core
+    'let
+    (letrec*
+      ((expand-let
+         (lambda (e r w s mod constructor ids vals exps)
+           (if (not (valid-bound-ids? ids))
+             (syntax-violation 'let "duplicate bound variable" e)
+             (let ((labels (gen-labels ids)) (new-vars (map gen-var ids)))
+               (let ((nw (make-binding-wrap ids labels w))
+                     (nr (extend-var-env labels new-vars r)))
+                 (constructor
+                   s
+                   (map syntax->datum ids)
+                   new-vars
+                   (map (lambda (x) (expand x r w mod)) vals)
+                   (expand-body exps (source-wrap e nw s mod) nr nw mod))))))))
+      (lambda (e r w s mod)
+        (let* ((tmp-1 e)
+               (tmp ($sc-dispatch tmp-1 '(_ #(each (any any)) any . 
each-any))))
+          (if (and tmp (apply (lambda (id val e1 e2) (and-map id? id)) tmp))
+            (apply (lambda (id val e1 e2)
+                     (expand-let e r w s mod build-let id val (cons e1 e2)))
+                   tmp)
+            (let ((tmp ($sc-dispatch tmp-1 '(_ any #(each (any any)) any . 
each-any))))
+              (if (and tmp
+                       (apply (lambda (f id val e1 e2) (and (id? f) (and-map 
id? id))) tmp))
+                (apply (lambda (f id val e1 e2)
+                         (expand-let e r w s mod build-named-let (cons f id) 
val (cons e1 e2)))
+                       tmp)
+                (syntax-violation 'let "bad let" (source-wrap e w s 
mod)))))))))
+  (global-extend
+    'core
+    'letrec
+    (lambda (e r w s mod)
+      (let* ((tmp e)
+             (tmp ($sc-dispatch tmp '(_ #(each (any any)) any . each-any))))
+        (if (and tmp (apply (lambda (id val e1 e2) (and-map id? id)) tmp))
+          (apply (lambda (id val e1 e2)
+                   (let ((ids id))
+                     (if (not (valid-bound-ids? ids))
+                       (syntax-violation 'letrec "duplicate bound variable" e)
+                       (let ((labels (gen-labels ids)) (new-vars (map gen-var 
ids)))
+                         (let ((w (make-binding-wrap ids labels w))
+                               (r (extend-var-env labels new-vars r)))
+                           (build-letrec
+                             s
+                             #f
+                             (map syntax->datum ids)
+                             new-vars
+                             (map (lambda (x) (expand x r w mod)) val)
+                             (expand-body (cons e1 e2) (source-wrap e w s mod) 
r w mod)))))))
+                 tmp)
+          (syntax-violation 'letrec "bad letrec" (source-wrap e w s mod))))))
+  (global-extend
+    'core
+    'letrec*
+    (lambda (e r w s mod)
+      (let* ((tmp e)
+             (tmp ($sc-dispatch tmp '(_ #(each (any any)) any . each-any))))
+        (if (and tmp (apply (lambda (id val e1 e2) (and-map id? id)) tmp))
+          (apply (lambda (id val e1 e2)
+                   (let ((ids id))
+                     (if (not (valid-bound-ids? ids))
+                       (syntax-violation 'letrec* "duplicate bound variable" e)
+                       (let ((labels (gen-labels ids)) (new-vars (map gen-var 
ids)))
+                         (let ((w (make-binding-wrap ids labels w))
+                               (r (extend-var-env labels new-vars r)))
+                           (build-letrec
+                             s
+                             #t
+                             (map syntax->datum ids)
+                             new-vars
+                             (map (lambda (x) (expand x r w mod)) val)
+                             (expand-body (cons e1 e2) (source-wrap e w s mod) 
r w mod)))))))
+                 tmp)
+          (syntax-violation 'letrec* "bad letrec*" (source-wrap e w s mod))))))
+  (global-extend
+    'core
+    'set!
+    (lambda (e r w s mod)
+      (let* ((tmp-1 e) (tmp ($sc-dispatch tmp-1 '(_ any any))))
+        (if (and tmp (apply (lambda (id val) (id? id)) tmp))
+          (apply (lambda (id val)
+                   (let ((n (id-var-name id w))
+                         (id-mod (if (syntax-object? id) (syntax-object-module 
id) mod)))
+                     (let* ((b (lookup n r id-mod)) (key (car b)))
+                       (cond ((memv key '(lexical))
+                              (build-lexical-assignment
+                                s
+                                (syntax->datum id)
+                                (cdr b)
+                                (expand val r w mod)))
+                             ((memv key '(global))
+                              (build-global-assignment s n (expand val r w 
mod) id-mod))
+                             ((memv key '(macro))
+                              (let ((p (cdr b)))
+                                (if (procedure-property p 
'variable-transformer)
+                                  (expand (expand-macro p e r w s #f mod) r 
'(()) mod)
+                                  (syntax-violation
+                                    'set!
+                                    "not a variable transformer"
+                                    (wrap e w mod)
+                                    (wrap id w id-mod)))))
+                             ((memv key '(displaced-lexical))
+                              (syntax-violation 'set! "identifier out of 
context" (wrap id w mod)))
+                             (else (syntax-violation 'set! "bad set!" 
(source-wrap e w s mod)))))))
+                 tmp)
+          (let ((tmp ($sc-dispatch tmp-1 '(_ (any . each-any) any))))
+            (if tmp
+              (apply (lambda (head tail val)
+                       (call-with-values
+                         (lambda () (syntax-type head r '(()) #f #f mod #t))
+                         (lambda (type value formform ee ww ss modmod)
+                           (let ((key type))
+                             (if (memv key '(module-ref))
+                               (let ((val (expand val r w mod)))
+                                 (call-with-values
+                                   (lambda () (value (cons head tail) r w))
+                                   (lambda (e r w s* mod)
+                                     (let* ((tmp-1 e) (tmp (list tmp-1)))
+                                       (if (and tmp (apply (lambda (e) (id? 
e)) tmp))
+                                         (apply (lambda (e) 
(build-global-assignment s (syntax->datum e) val mod))
+                                                tmp)
+                                         (syntax-violation
+                                           #f
+                                           "source expression failed to match 
any pattern"
+                                           tmp-1))))))
+                               (build-application
+                                 s
+                                 (expand
+                                   (list '#(syntax-object setter ((top)) 
(hygiene guile)) head)
+                                   r
+                                   w
+                                   mod)
+                                 (map (lambda (e) (expand e r w mod)) (append 
tail (list val)))))))))
+                     tmp)
+              (syntax-violation 'set! "bad set!" (source-wrap e w s mod))))))))
+  (global-extend
+    'module-ref
+    '@
+    (lambda (e r w)
+      (let* ((tmp-1 e) (tmp ($sc-dispatch tmp-1 '(_ each-any any))))
+        (if (and tmp
+                 (apply (lambda (mod id) (and (and-map id? mod) (id? id))) 
tmp))
+          (apply (lambda (mod id)
+                   (values
+                     (syntax->datum id)
+                     r
+                     w
+                     #f
+                     (syntax->datum
+                       (cons '#(syntax-object public ((top)) (hygiene guile)) 
mod))))
+                 tmp)
+          (syntax-violation
+            #f
+            "source expression failed to match any pattern"
+            tmp-1)))))
+  (global-extend
+    'module-ref
+    '@@
+    (lambda (e r w)
+      (letrec*
+        ((remodulate
+           (lambda (x mod)
+             (cond ((pair? x) (cons (remodulate (car x) mod) (remodulate (cdr 
x) mod)))
+                   ((syntax-object? x)
+                    (make-syntax-object
+                      (remodulate (syntax-object-expression x) mod)
+                      (syntax-object-wrap x)
+                      mod))
+                   ((vector? x)
+                    (let* ((n (vector-length x)) (v (make-vector n)))
+                      (let loop ((i 0))
+                        (if (= i n)
+                          (begin (if #f #f) v)
+                          (begin
+                            (vector-set! v i (remodulate (vector-ref x i) mod))
+                            (loop (+ i 1)))))))
+                   (else x)))))
+        (let* ((tmp-1 e) (tmp ($sc-dispatch tmp-1 '(_ each-any any))))
+          (if (and tmp (apply (lambda (mod exp) (and-map id? mod)) tmp))
+            (apply (lambda (mod exp)
+                     (let ((mod (syntax->datum
+                                  (cons '#(syntax-object private ((top)) 
(hygiene guile)) mod))))
+                       (values (remodulate exp mod) r w (source-annotation 
exp) mod)))
+                   tmp)
+            (syntax-violation
+              #f
+              "source expression failed to match any pattern"
+              tmp-1))))))
+  (global-extend
+    'core
+    'if
+    (lambda (e r w s mod)
+      (let* ((tmp e) (tmp-1 ($sc-dispatch tmp '(_ any any))))
+        (if tmp-1
+          (apply (lambda (test then)
+                   (build-conditional
+                     s
+                     (expand test r w mod)
+                     (expand then r w mod)
+                     (build-void #f)))
+                 tmp-1)
+          (let ((tmp-1 ($sc-dispatch tmp '(_ any any any))))
+            (if tmp-1
+              (apply (lambda (test then else)
+                       (build-conditional
+                         s
+                         (expand test r w mod)
+                         (expand then r w mod)
+                         (expand else r w mod)))
+                     tmp-1)
+              (syntax-violation
+                #f
+                "source expression failed to match any pattern"
+                tmp)))))))
+  (global-extend
+    'core
+    'with-fluids
+    (lambda (e r w s mod)
+      (let* ((tmp-1 e)
+             (tmp ($sc-dispatch tmp-1 '(_ #(each (any any)) any . each-any))))
+        (if tmp
+          (apply (lambda (fluid val b b*)
+                   (build-dynlet
+                     s
+                     (map (lambda (x) (expand x r w mod)) fluid)
+                     (map (lambda (x) (expand x r w mod)) val)
+                     (expand-body (cons b b*) (source-wrap e w s mod) r w 
mod)))
+                 tmp)
+          (syntax-violation
+            #f
+            "source expression failed to match any pattern"
+            tmp-1)))))
+  (global-extend 'begin 'begin '())
+  (global-extend 'define 'define '())
+  (global-extend 'define-syntax 'define-syntax '())
+  (global-extend 'define-syntax-parameter 'define-syntax-parameter '())
+  (global-extend 'eval-when 'eval-when '())
+  (global-extend
+    'core
+    'syntax-case
+    (letrec*
+      ((convert-pattern
+         (lambda (pattern keys)
+           (letrec*
+             ((cvt* (lambda (p* n ids)
+                      (if (not (pair? p*))
+                        (cvt p* n ids)
                         (call-with-values
-                          (lambda ()
-                            (cvt*-12020 (cdr p*-12644) n-12645 ids-12646))
-                          (lambda (y-12649 ids-12650)
+                          (lambda () (cvt* (cdr p*) n ids))
+                          (lambda (y ids)
                             (call-with-values
-                              (lambda ()
-                                (cvt-12022 (car p*-12644) n-12645 ids-12650))
-                              (lambda (x-12653 ids-12654)
-                                (values
-                                  (cons x-12653 y-12649)
-                                  ids-12654))))))))
-                  (v-reverse-12021
-                    (lambda (x-12655)
-                      (letrec*
-                        ((loop-12656
-                           (lambda (r-12736 x-12737)
-                             (if (not (pair? x-12737))
-                               (values r-12736 x-12737)
-                               (loop-12656
-                                 (cons (car x-12737) r-12736)
-                                 (cdr x-12737))))))
-                        (loop-12656 '() x-12655))))
-                  (cvt-12022
-                    (lambda (p-12025 n-12026 ids-12027)
-                      (if (if (symbol? p-12025)
-                            #t
-                            (if (if (vector? p-12025)
-                                  (if (= (vector-length p-12025) 4)
-                                    (eq? (vector-ref p-12025 0) 'syntax-object)
-                                    #f)
-                                  #f)
-                              (symbol? (vector-ref p-12025 1))
-                              #f))
-                        (if (bound-id-member?-4289 p-12025 keys-12019)
-                          (values (vector 'free-id p-12025) ids-12027)
-                          (if (if (eq? (if (if (vector? p-12025)
-                                             (if (= (vector-length p-12025) 4)
-                                               (eq? (vector-ref p-12025 0)
-                                                    'syntax-object)
-                                               #f)
-                                             #f)
-                                         (vector-ref p-12025 1)
-                                         p-12025)
-                                       (if (if (= (vector-length
-                                                    '#(syntax-object
-                                                       _
-                                                       ((top)
-                                                        #(ribcage () () ())
-                                                        #(ribcage
-                                                          #(p n ids)
-                                                          #((top) (top) (top))
-                                                          #("l-*-3705"
-                                                            "l-*-3706"
-                                                            "l-*-3707"))
-                                                        #(ribcage
-                                                          (cvt v-reverse cvt*)
-                                                          ((top) (top) (top))
-                                                          ("l-*-3678"
-                                                           "l-*-3676"
-                                                           "l-*-3674"))
-                                                        #(ribcage
-                                                          #(pattern keys)
-                                                          #((top) (top))
-                                                          #("l-*-3672"
-                                                            "l-*-3673"))
-                                                        #(ribcage
-                                                          (gen-syntax-case
-                                                            gen-clause
-                                                            build-dispatch-call
-                                                            convert-pattern)
-                                                          ((top)
-                                                           (top)
-                                                           (top)
-                                                           (top))
-                                                          ("l-*-3668"
-                                                           "l-*-3666"
-                                                           "l-*-3664"
-                                                           "l-*-3662"))
-                                                        #(ribcage
-                                                          (lambda-var-list
-                                                            gen-var
-                                                            strip
-                                                            expand-lambda-case
-                                                            lambda*-formals
-                                                            
expand-simple-lambda
-                                                            lambda-formals
-                                                            ellipsis?
-                                                            expand-void
-                                                            
eval-local-transformer
-                                                            expand-local-syntax
-                                                            expand-body
-                                                            expand-macro
-                                                            expand-application
-                                                            expand-expr
-                                                            expand
-                                                            syntax-type
-                                                            parse-when-list
-                                                            
expand-install-global
-                                                            expand-top-sequence
-                                                            expand-sequence
-                                                            source-wrap
-                                                            wrap
-                                                            bound-id-member?
-                                                            distinct-bound-ids?
-                                                            valid-bound-ids?
-                                                            bound-id=?
-                                                            free-id=?
-                                                            
with-transformer-environment
-                                                            
transformer-environment
-                                                            resolve-identifier
-                                                            
locally-bound-identifiers
-                                                            id-var-name
-                                                            same-marks?
-                                                            join-marks
-                                                            join-wraps
-                                                            smart-append
-                                                            make-binding-wrap
-                                                            extend-ribcage!
-                                                            make-empty-ribcage
-                                                            new-mark
-                                                            anti-mark
-                                                            the-anti-mark
-                                                            top-marked?
-                                                            top-wrap
-                                                            empty-wrap
-                                                            set-ribcage-labels!
-                                                            set-ribcage-marks!
-                                                            
set-ribcage-symnames!
-                                                            ribcage-labels
-                                                            ribcage-marks
-                                                            ribcage-symnames
-                                                            ribcage?
-                                                            make-ribcage
-                                                            gen-labels
-                                                            gen-label
-                                                            make-rename
-                                                            rename-marks
-                                                            rename-new
-                                                            rename-old
-                                                            subst-rename?
-                                                            wrap-subst
-                                                            wrap-marks
-                                                            make-wrap
-                                                            id-sym-name&marks
-                                                            id-sym-name
-                                                            id?
-                                                            nonsymbol-id?
-                                                            global-extend
-                                                            lookup
-                                                            macros-only-env
-                                                            extend-var-env
-                                                            extend-env
-                                                            null-env
-                                                            binding-value
-                                                            binding-type
-                                                            make-binding
-                                                            arg-check
-                                                            source-annotation
-                                                            no-source
-                                                            
set-syntax-object-module!
-                                                            
set-syntax-object-wrap!
-                                                            
set-syntax-object-expression!
-                                                            
syntax-object-module
-                                                            syntax-object-wrap
-                                                            
syntax-object-expression
-                                                            syntax-object?
-                                                            make-syntax-object
-                                                            build-lexical-var
-                                                            build-letrec
-                                                            build-named-let
-                                                            build-let
-                                                            build-sequence
-                                                            build-data
-                                                            build-primref
-                                                            build-lambda-case
-                                                            build-case-lambda
-                                                            build-simple-lambda
-                                                            
build-global-definition
-                                                            
build-global-assignment
-                                                            
build-global-reference
-                                                            analyze-variable
-                                                            
build-lexical-assignment
-                                                            
build-lexical-reference
-                                                            build-dynlet
-                                                            build-conditional
-                                                            build-application
-                                                            build-void
-                                                            maybe-name-value!
-                                                            decorate-source
-                                                            
get-global-definition-hook
-                                                            
put-global-definition-hook
-                                                            session-id
-                                                            local-eval-hook
-                                                            top-level-eval-hook
-                                                            fx<
-                                                            fx=
-                                                            fx-
-                                                            fx+
-                                                            set-lambda-meta!
-                                                            lambda-meta
-                                                            lambda?
-                                                            make-dynlet
-                                                            make-letrec
-                                                            make-let
-                                                            make-lambda-case
-                                                            make-lambda
-                                                            make-sequence
-                                                            make-application
-                                                            make-conditional
-                                                            
make-toplevel-define
-                                                            make-toplevel-set
-                                                            make-toplevel-ref
-                                                            make-module-set
-                                                            make-module-ref
-                                                            make-lexical-set
-                                                            make-lexical-ref
-                                                            make-primitive-ref
-                                                            make-const
-                                                            make-void)
-                                                          ((top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top)
-                                                           (top))
-                                                          ("l-*-476"
-                                                           "l-*-474"
-                                                           "l-*-472"
-                                                           "l-*-470"
-                                                           "l-*-468"
-                                                           "l-*-466"
-                                                           "l-*-464"
-                                                           "l-*-462"
-                                                           "l-*-460"
-                                                           "l-*-458"
-                                                           "l-*-456"
-                                                           "l-*-454"
-                                                           "l-*-452"
-                                                           "l-*-450"
-                                                           "l-*-448"
-                                                           "l-*-446"
-                                                           "l-*-444"
-                                                           "l-*-442"
-                                                           "l-*-440"
-                                                           "l-*-438"
-                                                           "l-*-436"
-                                                           "l-*-434"
-                                                           "l-*-432"
-                                                           "l-*-430"
-                                                           "l-*-428"
-                                                           "l-*-426"
-                                                           "l-*-424"
-                                                           "l-*-422"
-                                                           "l-*-420"
-                                                           "l-*-418"
-                                                           "l-*-416"
-                                                           "l-*-414"
-                                                           "l-*-412"
-                                                           "l-*-410"
-                                                           "l-*-408"
-                                                           "l-*-406"
-                                                           "l-*-404"
-                                                           "l-*-402"
-                                                           "l-*-400"
-                                                           "l-*-399"
-                                                           "l-*-397"
-                                                           "l-*-394"
-                                                           "l-*-393"
-                                                           "l-*-392"
-                                                           "l-*-390"
-                                                           "l-*-389"
-                                                           "l-*-387"
-                                                           "l-*-385"
-                                                           "l-*-383"
-                                                           "l-*-381"
-                                                           "l-*-379"
-                                                           "l-*-377"
-                                                           "l-*-375"
-                                                           "l-*-373"
-                                                           "l-*-370"
-                                                           "l-*-368"
-                                                           "l-*-367"
-                                                           "l-*-365"
-                                                           "l-*-363"
-                                                           "l-*-361"
-                                                           "l-*-359"
-                                                           "l-*-358"
-                                                           "l-*-357"
-                                                           "l-*-356"
-                                                           "l-*-354"
-                                                           "l-*-353"
-                                                           "l-*-350"
-                                                           "l-*-348"
-                                                           "l-*-346"
-                                                           "l-*-344"
-                                                           "l-*-342"
-                                                           "l-*-340"
-                                                           "l-*-338"
-                                                           "l-*-337"
-                                                           "l-*-336"
-                                                           "l-*-334"
-                                                           "l-*-332"
-                                                           "l-*-331"
-                                                           "l-*-328"
-                                                           "l-*-327"
-                                                           "l-*-325"
-                                                           "l-*-323"
-                                                           "l-*-321"
-                                                           "l-*-319"
-                                                           "l-*-317"
-                                                           "l-*-315"
-                                                           "l-*-313"
-                                                           "l-*-311"
-                                                           "l-*-309"
-                                                           "l-*-306"
-                                                           "l-*-304"
-                                                           "l-*-302"
-                                                           "l-*-300"
-                                                           "l-*-298"
-                                                           "l-*-296"
-                                                           "l-*-294"
-                                                           "l-*-292"
-                                                           "l-*-290"
-                                                           "l-*-288"
-                                                           "l-*-286"
-                                                           "l-*-284"
-                                                           "l-*-282"
-                                                           "l-*-280"
-                                                           "l-*-278"
-                                                           "l-*-276"
-                                                           "l-*-274"
-                                                           "l-*-272"
-                                                           "l-*-270"
-                                                           "l-*-268"
-                                                           "l-*-266"
-                                                           "l-*-264"
-                                                           "l-*-262"
-                                                           "l-*-260"
-                                                           "l-*-258"
-                                                           "l-*-256"
-                                                           "l-*-255"
-                                                           "l-*-254"
-                                                           "l-*-253"
-                                                           "l-*-252"
-                                                           "l-*-250"
-                                                           "l-*-248"
-                                                           "l-*-246"
-                                                           "l-*-243"
-                                                           "l-*-241"
-                                                           "l-*-239"
-                                                           "l-*-237"
-                                                           "l-*-235"
-                                                           "l-*-233"
-                                                           "l-*-231"
-                                                           "l-*-229"
-                                                           "l-*-227"
-                                                           "l-*-225"
-                                                           "l-*-223"
-                                                           "l-*-221"
-                                                           "l-*-219"
-                                                           "l-*-217"
-                                                           "l-*-215"
-                                                           "l-*-213"
-                                                           "l-*-211"
-                                                           "l-*-209"))
-                                                        #(ribcage
-                                                          (define-structure
-                                                            
define-expansion-accessors
-                                                            
define-expansion-constructors)
-                                                          ((top) (top) (top))
-                                                          ("l-*-47"
-                                                           "l-*-46"
-                                                           "l-*-45")))
-                                                       (hygiene guile)))
-                                                  4)
-                                             #t
-                                             #f)
-                                         '_
-                                         '#(syntax-object
-                                            _
-                                            ((top)
-                                             #(ribcage () () ())
-                                             #(ribcage
-                                               #(p n ids)
-                                               #((top) (top) (top))
-                                               #("l-*-3705"
-                                                 "l-*-3706"
-                                                 "l-*-3707"))
-                                             #(ribcage
-                                               (cvt v-reverse cvt*)
-                                               ((top) (top) (top))
-                                               ("l-*-3678"
-                                                "l-*-3676"
-                                                "l-*-3674"))
-                                             #(ribcage
-                                               #(pattern keys)
-                                               #((top) (top))
-                                               #("l-*-3672" "l-*-3673"))
-                                             #(ribcage
-                                               (gen-syntax-case
-                                                 gen-clause
-                                                 build-dispatch-call
-                                                 convert-pattern)
-                                               ((top) (top) (top) (top))
-                                               ("l-*-3668"
-                                                "l-*-3666"
-                                                "l-*-3664"
-                                                "l-*-3662"))
-                                             #(ribcage
-                                               (lambda-var-list
-                                                 gen-var
-                                                 strip
-                                                 expand-lambda-case
-                                                 lambda*-formals
-                                                 expand-simple-lambda
-                                                 lambda-formals
-                                                 ellipsis?
-                                                 expand-void
-                                                 eval-local-transformer
-                                                 expand-local-syntax
-                                                 expand-body
-                                                 expand-macro
-                                                 expand-application
-                                                 expand-expr
-                                                 expand
-                                                 syntax-type
-                                                 parse-when-list
-                                                 expand-install-global
-                                                 expand-top-sequence
-                                                 expand-sequence
-                                                 source-wrap
-                                                 wrap
-                                                 bound-id-member?
-                                                 distinct-bound-ids?
-                                                 valid-bound-ids?
-                                                 bound-id=?
-                                                 free-id=?
-                                                 with-transformer-environment
-                                                 transformer-environment
-                                                 resolve-identifier
-                                                 locally-bound-identifiers
-                                                 id-var-name
-                                                 same-marks?
-                                                 join-marks
-                                                 join-wraps
-                                                 smart-append
-                                                 make-binding-wrap
-                                                 extend-ribcage!
-                                                 make-empty-ribcage
-                                                 new-mark
-                                                 anti-mark
-                                                 the-anti-mark
-                                                 top-marked?
-                                                 top-wrap
-                                                 empty-wrap
-                                                 set-ribcage-labels!
-                                                 set-ribcage-marks!
-                                                 set-ribcage-symnames!
-                                                 ribcage-labels
-                                                 ribcage-marks
-                                                 ribcage-symnames
-                                                 ribcage?
-                                                 make-ribcage
-                                                 gen-labels
-                                                 gen-label
-                                                 make-rename
-                                                 rename-marks
-                                                 rename-new
-                                                 rename-old
-                                                 subst-rename?
-                                                 wrap-subst
-                                                 wrap-marks
-                                                 make-wrap
-                                                 id-sym-name&marks
-                                                 id-sym-name
-                                                 id?
-                                                 nonsymbol-id?
-                                                 global-extend
-                                                 lookup
-                                                 macros-only-env
-                                                 extend-var-env
-                                                 extend-env
-                                                 null-env
-                                                 binding-value
-                                                 binding-type
-                                                 make-binding
-                                                 arg-check
-                                                 source-annotation
-                                                 no-source
-                                                 set-syntax-object-module!
-                                                 set-syntax-object-wrap!
-                                                 set-syntax-object-expression!
-                                                 syntax-object-module
-                                                 syntax-object-wrap
-                                                 syntax-object-expression
-                                                 syntax-object?
-                                                 make-syntax-object
-                                                 build-lexical-var
-                                                 build-letrec
-                                                 build-named-let
-                                                 build-let
-                                                 build-sequence
-                                                 build-data
-                                                 build-primref
-                                                 build-lambda-case
-                                                 build-case-lambda
-                                                 build-simple-lambda
-                                                 build-global-definition
-                                                 build-global-assignment
-                                                 build-global-reference
-                                                 analyze-variable
-                                                 build-lexical-assignment
-                                                 build-lexical-reference
-                                                 build-dynlet
-                                                 build-conditional
-                                                 build-application
-                                                 build-void
-                                                 maybe-name-value!
-                                                 decorate-source
-                                                 get-global-definition-hook
-                                                 put-global-definition-hook
-                                                 session-id
-                                                 local-eval-hook
-                                                 top-level-eval-hook
-                                                 fx<
-                                                 fx=
-                                                 fx-
-                                                 fx+
-                                                 set-lambda-meta!
-                                                 lambda-meta
-                                                 lambda?
-                                                 make-dynlet
-                                                 make-letrec
-                                                 make-let
-                                                 make-lambda-case
-                                                 make-lambda
-                                                 make-sequence
-                                                 make-application
-                                                 make-conditional
-                                                 make-toplevel-define
-                                                 make-toplevel-set
-                                                 make-toplevel-ref
-                                                 make-module-set
-                                                 make-module-ref
-                                                 make-lexical-set
-                                                 make-lexical-ref
-                                                 make-primitive-ref
-                                                 make-const
-                                                 make-void)
-                                               ((top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top)
-                                                (top))
-                                               ("l-*-476"
-                                                "l-*-474"
-                                                "l-*-472"
-                                                "l-*-470"
-                                                "l-*-468"
-                                                "l-*-466"
-                                                "l-*-464"
-                                                "l-*-462"
-                                                "l-*-460"
-                                                "l-*-458"
-                                                "l-*-456"
-                                                "l-*-454"
-                                                "l-*-452"
-                                                "l-*-450"
-                                                "l-*-448"
-                                                "l-*-446"
-                                                "l-*-444"
-                                                "l-*-442"
-                                                "l-*-440"
-                                                "l-*-438"
-                                                "l-*-436"
-                                                "l-*-434"
-                                                "l-*-432"
-                                                "l-*-430"
-                                                "l-*-428"
-                                                "l-*-426"
-                                                "l-*-424"
-                                                "l-*-422"
-                                                "l-*-420"
-                                                "l-*-418"
-                                                "l-*-416"
-                                                "l-*-414"
-                                                "l-*-412"
-                                                "l-*-410"
-                                                "l-*-408"
-                                                "l-*-406"
-                                                "l-*-404"
-                                                "l-*-402"
-                                                "l-*-400"
-                                                "l-*-399"
-                                                "l-*-397"
-                                                "l-*-394"
-                                                "l-*-393"
-                                                "l-*-392"
-                                                "l-*-390"
-                                                "l-*-389"
-                                                "l-*-387"
-                                                "l-*-385"
-                                                "l-*-383"
-                                                "l-*-381"
-                                                "l-*-379"
-                                                "l-*-377"
-                                                "l-*-375"
-                                                "l-*-373"
-                                                "l-*-370"
-                                                "l-*-368"
-                                                "l-*-367"
-                                                "l-*-365"
-                                                "l-*-363"
-                                                "l-*-361"
-                                                "l-*-359"
-                                                "l-*-358"
-                                                "l-*-357"
-                                                "l-*-356"
-                                                "l-*-354"
-                                                "l-*-353"
-                                                "l-*-350"
-                                                "l-*-348"
-                                                "l-*-346"
-                                                "l-*-344"
-                                                "l-*-342"
-                                                "l-*-340"
-                                                "l-*-338"
-                                                "l-*-337"
-                                                "l-*-336"
-                                                "l-*-334"
-                                                "l-*-332"
-                                                "l-*-331"
-                                                "l-*-328"
-                                                "l-*-327"
-                                                "l-*-325"
-                                                "l-*-323"
-                                                "l-*-321"
-                                                "l-*-319"
-                                                "l-*-317"
-                                                "l-*-315"
-                                                "l-*-313"
-                                                "l-*-311"
-                                                "l-*-309"
-                                                "l-*-306"
-                                                "l-*-304"
-                                                "l-*-302"
-                                                "l-*-300"
-                                                "l-*-298"
-                                                "l-*-296"
-                                                "l-*-294"
-                                                "l-*-292"
-                                                "l-*-290"
-                                                "l-*-288"
-                                                "l-*-286"
-                                                "l-*-284"
-                                                "l-*-282"
-                                                "l-*-280"
-                                                "l-*-278"
-                                                "l-*-276"
-                                                "l-*-274"
-                                                "l-*-272"
-                                                "l-*-270"
-                                                "l-*-268"
-                                                "l-*-266"
-                                                "l-*-264"
-                                                "l-*-262"
-                                                "l-*-260"
-                                                "l-*-258"
-                                                "l-*-256"
-                                                "l-*-255"
-                                                "l-*-254"
-                                                "l-*-253"
-                                                "l-*-252"
-                                                "l-*-250"
-                                                "l-*-248"
-                                                "l-*-246"
-                                                "l-*-243"
-                                                "l-*-241"
-                                                "l-*-239"
-                                                "l-*-237"
-                                                "l-*-235"
-                                                "l-*-233"
-                                                "l-*-231"
-                                                "l-*-229"
-                                                "l-*-227"
-                                                "l-*-225"
-                                                "l-*-223"
-                                                "l-*-221"
-                                                "l-*-219"
-                                                "l-*-217"
-                                                "l-*-215"
-                                                "l-*-213"
-                                                "l-*-211"
-                                                "l-*-209"))
-                                             #(ribcage
-                                               (define-structure
-                                                 define-expansion-accessors
-                                                 define-expansion-constructors)
-                                               ((top) (top) (top))
-                                               ("l-*-47" "l-*-46" "l-*-45")))
-                                            (hygiene guile))))
-                                (eq? (id-var-name-4280 p-12025 '(()))
-                                     (id-var-name-4280
-                                       '#(syntax-object
-                                          _
-                                          ((top)
-                                           #(ribcage () () ())
-                                           #(ribcage
-                                             #(p n ids)
-                                             #((top) (top) (top))
-                                             #("l-*-3705"
-                                               "l-*-3706"
-                                               "l-*-3707"))
-                                           #(ribcage
-                                             (cvt v-reverse cvt*)
-                                             ((top) (top) (top))
-                                             ("l-*-3678"
-                                              "l-*-3676"
-                                              "l-*-3674"))
-                                           #(ribcage
-                                             #(pattern keys)
-                                             #((top) (top))
-                                             #("l-*-3672" "l-*-3673"))
-                                           #(ribcage
-                                             (gen-syntax-case
-                                               gen-clause
-                                               build-dispatch-call
-                                               convert-pattern)
-                                             ((top) (top) (top) (top))
-                                             ("l-*-3668"
-                                              "l-*-3666"
-                                              "l-*-3664"
-                                              "l-*-3662"))
-                                           #(ribcage
-                                             (lambda-var-list
-                                               gen-var
-                                               strip
-                                               expand-lambda-case
-                                               lambda*-formals
-                                               expand-simple-lambda
-                                               lambda-formals
-                                               ellipsis?
-                                               expand-void
-                                               eval-local-transformer
-                                               expand-local-syntax
-                                               expand-body
-                                               expand-macro
-                                               expand-application
-                                               expand-expr
-                                               expand
-                                               syntax-type
-                                               parse-when-list
-                                               expand-install-global
-                                               expand-top-sequence
-                                               expand-sequence
-                                               source-wrap
-                                               wrap
-                                               bound-id-member?
-                                               distinct-bound-ids?
-                                               valid-bound-ids?
-                                               bound-id=?
-                                               free-id=?
-                                               with-transformer-environment
-                                               transformer-environment
-                                               resolve-identifier
-                                               locally-bound-identifiers
-                                               id-var-name
-                                               same-marks?
-                                               join-marks
-                                               join-wraps
-                                               smart-append
-                                               make-binding-wrap
-                                               extend-ribcage!
-                                               make-empty-ribcage
-                                               new-mark
-                                               anti-mark
-                                               the-anti-mark
-                                               top-marked?
-                                               top-wrap
-                                               empty-wrap
-                                               set-ribcage-labels!
-                                               set-ribcage-marks!
-                                               set-ribcage-symnames!
-                                               ribcage-labels
-                                               ribcage-marks
-                                               ribcage-symnames
-                                               ribcage?
-                                               make-ribcage
-                                               gen-labels
-                                               gen-label
-                                               make-rename
-                                               rename-marks
-                                               rename-new
-                                               rename-old
-                                               subst-rename?
-                                               wrap-subst
-                                               wrap-marks
-                                               make-wrap
-                                               id-sym-name&marks
-                                               id-sym-name
-                                               id?
-                                               nonsymbol-id?
-                                               global-extend
-                                               lookup
-                                               macros-only-env
-                                               extend-var-env
-                                               extend-env
-                                               null-env
-                                               binding-value
-                                               binding-type
-                                               make-binding
-                                               arg-check
-                                               source-annotation
-                                               no-source
-                                               set-syntax-object-module!
-                                               set-syntax-object-wrap!
-                                               set-syntax-object-expression!
-                                               syntax-object-module
-                                               syntax-object-wrap
-                                               syntax-object-expression
-                                               syntax-object?
-                                               make-syntax-object
-                                               build-lexical-var
-                                               build-letrec
-                                               build-named-let
-                                               build-let
-                                               build-sequence
-                                               build-data
-                                               build-primref
-                                               build-lambda-case
-                                               build-case-lambda
-                                               build-simple-lambda
-                                               build-global-definition
-                                               build-global-assignment
-                                               build-global-reference
-                                               analyze-variable
-                                               build-lexical-assignment
-                                               build-lexical-reference
-                                               build-dynlet
-                                               build-conditional
-                                               build-application
-                                               build-void
-                                               maybe-name-value!
-                                               decorate-source
-                                               get-global-definition-hook
-                                               put-global-definition-hook
-                                               session-id
-                                               local-eval-hook
-                                               top-level-eval-hook
-                                               fx<
-                                               fx=
-                                               fx-
-                                               fx+
-                                               set-lambda-meta!
-                                               lambda-meta
-                                               lambda?
-                                               make-dynlet
-                                               make-letrec
-                                               make-let
-                                               make-lambda-case
-                                               make-lambda
-                                               make-sequence
-                                               make-application
-                                               make-conditional
-                                               make-toplevel-define
-                                               make-toplevel-set
-                                               make-toplevel-ref
-                                               make-module-set
-                                               make-module-ref
-                                               make-lexical-set
-                                               make-lexical-ref
-                                               make-primitive-ref
-                                               make-const
-                                               make-void)
-                                             ((top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top)
-                                              (top))
-                                             ("l-*-476"
-                                              "l-*-474"
-                                              "l-*-472"
-                                              "l-*-470"
-                                              "l-*-468"
-                                              "l-*-466"
-                                              "l-*-464"
-                                              "l-*-462"
-                                              "l-*-460"
-                                              "l-*-458"
-                                              "l-*-456"
-                                              "l-*-454"
-                                              "l-*-452"
-                                              "l-*-450"
-                                              "l-*-448"
-                                              "l-*-446"
-                                              "l-*-444"
-                                              "l-*-442"
-                                              "l-*-440"
-                                              "l-*-438"
-                                              "l-*-436"
-                                              "l-*-434"
-                                              "l-*-432"
-                                              "l-*-430"
-                                              "l-*-428"
-                                              "l-*-426"
-                                              "l-*-424"
-                                              "l-*-422"
-                                              "l-*-420"
-                                              "l-*-418"
-                                              "l-*-416"
-                                              "l-*-414"
-                                              "l-*-412"
-                                              "l-*-410"
-                                              "l-*-408"
-                                              "l-*-406"
-                                              "l-*-404"
-                                              "l-*-402"
-                                              "l-*-400"
-                                              "l-*-399"
-                                              "l-*-397"
-                                              "l-*-394"
-                                              "l-*-393"
-                                              "l-*-392"
-                                              "l-*-390"
-                                              "l-*-389"
-                                              "l-*-387"
-                                              "l-*-385"
-                                              "l-*-383"
-                                              "l-*-381"
-                                              "l-*-379"
-                                              "l-*-377"
-                                              "l-*-375"
-                                              "l-*-373"
-                                              "l-*-370"
-                                              "l-*-368"
-                                              "l-*-367"
-                                              "l-*-365"
-                                              "l-*-363"
-                                              "l-*-361"
-                                              "l-*-359"
-                                              "l-*-358"
-                                              "l-*-357"
-                                              "l-*-356"
-                                              "l-*-354"
-                                              "l-*-353"
-                                              "l-*-350"
-                                              "l-*-348"
-                                              "l-*-346"
-                                              "l-*-344"
-                                              "l-*-342"
-                                              "l-*-340"
-                                              "l-*-338"
-                                              "l-*-337"
-                                              "l-*-336"
-                                              "l-*-334"
-                                              "l-*-332"
-                                              "l-*-331"
-                                              "l-*-328"
-                                              "l-*-327"
-                                              "l-*-325"
-                                              "l-*-323"
-                                              "l-*-321"
-                                              "l-*-319"
-                                              "l-*-317"
-                                              "l-*-315"
-                                              "l-*-313"
-                                              "l-*-311"
-                                              "l-*-309"
-                                              "l-*-306"
-                                              "l-*-304"
-                                              "l-*-302"
-                                              "l-*-300"
-                                              "l-*-298"
-                                              "l-*-296"
-                                              "l-*-294"
-                                              "l-*-292"
-                                              "l-*-290"
-                                              "l-*-288"
-                                              "l-*-286"
-                                              "l-*-284"
-                                              "l-*-282"
-                                              "l-*-280"
-                                              "l-*-278"
-                                              "l-*-276"
-                                              "l-*-274"
-                                              "l-*-272"
-                                              "l-*-270"
-                                              "l-*-268"
-                                              "l-*-266"
-                                              "l-*-264"
-                                              "l-*-262"
-                                              "l-*-260"
-                                              "l-*-258"
-                                              "l-*-256"
-                                              "l-*-255"
-                                              "l-*-254"
-                                              "l-*-253"
-                                              "l-*-252"
-                                              "l-*-250"
-                                              "l-*-248"
-                                              "l-*-246"
-                                              "l-*-243"
-                                              "l-*-241"
-                                              "l-*-239"
-                                              "l-*-237"
-                                              "l-*-235"
-                                              "l-*-233"
-                                              "l-*-231"
-                                              "l-*-229"
-                                              "l-*-227"
-                                              "l-*-225"
-                                              "l-*-223"
-                                              "l-*-221"
-                                              "l-*-219"
-                                              "l-*-217"
-                                              "l-*-215"
-                                              "l-*-213"
-                                              "l-*-211"
-                                              "l-*-209"))
-                                           #(ribcage
-                                             (define-structure
-                                               define-expansion-accessors
-                                               define-expansion-constructors)
-                                             ((top) (top) (top))
-                                             ("l-*-47" "l-*-46" "l-*-45")))
-                                          (hygiene guile))
-                                       '(())))
-                                #f)
-                            (values '_ ids-12027)
-                            (values
-                              'any
-                              (cons (cons p-12025 n-12026) ids-12027))))
-                        (let ((tmp-12347 ($sc-dispatch p-12025 '(any any))))
-                          (if (if tmp-12347
-                                (@apply
-                                  (lambda (x-12351 dots-12352)
-                                    (if (if (if (vector? dots-12352)
-                                              (if (= (vector-length dots-12352)
-                                                     4)
-                                                (eq? (vector-ref dots-12352 0)
-                                                     'syntax-object)
-                                                #f)
-                                              #f)
-                                          (symbol? (vector-ref dots-12352 1))
-                                          #f)
-                                      (if (eq? (if (if (vector? dots-12352)
-                                                     (if (= (vector-length
-                                                              dots-12352)
-                                                            4)
-                                                       (eq? (vector-ref
-                                                              dots-12352
-                                                              0)
-                                                            'syntax-object)
-                                                       #f)
-                                                     #f)
-                                                 (vector-ref dots-12352 1)
-                                                 dots-12352)
-                                               (if (if (= (vector-length
-                                                            '#(syntax-object
-                                                               ...
-                                                               ((top)
-                                                                #(ribcage
-                                                                  ()
-                                                                  ()
-                                                                  ())
-                                                                #(ribcage
-                                                                  ()
-                                                                  ()
-                                                                  ())
-                                                                #(ribcage
-                                                                  #(x)
-                                                                  #((top))
-                                                                  
#("l-*-2265"))
-                                                                #(ribcage
-                                                                  
(lambda-var-list
-                                                                    gen-var
-                                                                    strip
-                                                                    
expand-lambda-case
-                                                                    
lambda*-formals
-                                                                    
expand-simple-lambda
-                                                                    
lambda-formals
-                                                                    ellipsis?
-                                                                    expand-void
-                                                                    
eval-local-transformer
-                                                                    
expand-local-syntax
-                                                                    expand-body
-                                                                    
expand-macro
-                                                                    
expand-application
-                                                                    expand-expr
-                                                                    expand
-                                                                    syntax-type
-                                                                    
parse-when-list
-                                                                    
expand-install-global
-                                                                    
expand-top-sequence
-                                                                    
expand-sequence
-                                                                    source-wrap
-                                                                    wrap
-                                                                    
bound-id-member?
-                                                                    
distinct-bound-ids?
-                                                                    
valid-bound-ids?
-                                                                    bound-id=?
-                                                                    free-id=?
-                                                                    
with-transformer-environment
-                                                                    
transformer-environment
-                                                                    
resolve-identifier
-                                                                    
locally-bound-identifiers
-                                                                    id-var-name
-                                                                    same-marks?
-                                                                    join-marks
-                                                                    join-wraps
-                                                                    
smart-append
-                                                                    
make-binding-wrap
-                                                                    
extend-ribcage!
-                                                                    
make-empty-ribcage
-                                                                    new-mark
-                                                                    anti-mark
-                                                                    
the-anti-mark
-                                                                    top-marked?
-                                                                    top-wrap
-                                                                    empty-wrap
-                                                                    
set-ribcage-labels!
-                                                                    
set-ribcage-marks!
-                                                                    
set-ribcage-symnames!
-                                                                    
ribcage-labels
-                                                                    
ribcage-marks
-                                                                    
ribcage-symnames
-                                                                    ribcage?
-                                                                    
make-ribcage
-                                                                    gen-labels
-                                                                    gen-label
-                                                                    make-rename
-                                                                    
rename-marks
-                                                                    rename-new
-                                                                    rename-old
-                                                                    
subst-rename?
-                                                                    wrap-subst
-                                                                    wrap-marks
-                                                                    make-wrap
-                                                                    
id-sym-name&marks
-                                                                    id-sym-name
-                                                                    id?
-                                                                    
nonsymbol-id?
-                                                                    
global-extend
-                                                                    lookup
-                                                                    
macros-only-env
-                                                                    
extend-var-env
-                                                                    extend-env
-                                                                    null-env
-                                                                    
binding-value
-                                                                    
binding-type
-                                                                    
make-binding
-                                                                    arg-check
-                                                                    
source-annotation
-                                                                    no-source
-                                                                    
set-syntax-object-module!
-                                                                    
set-syntax-object-wrap!
-                                                                    
set-syntax-object-expression!
-                                                                    
syntax-object-module
-                                                                    
syntax-object-wrap
-                                                                    
syntax-object-expression
-                                                                    
syntax-object?
-                                                                    
make-syntax-object
-                                                                    
build-lexical-var
-                                                                    
build-letrec
-                                                                    
build-named-let
-                                                                    build-let
-                                                                    
build-sequence
-                                                                    build-data
-                                                                    
build-primref
-                                                                    
build-lambda-case
-                                                                    
build-case-lambda
-                                                                    
build-simple-lambda
-                                                                    
build-global-definition
-                                                                    
build-global-assignment
-                                                                    
build-global-reference
-                                                                    
analyze-variable
-                                                                    
build-lexical-assignment
-                                                                    
build-lexical-reference
-                                                                    
build-dynlet
-                                                                    
build-conditional
-                                                                    
build-application
-                                                                    build-void
-                                                                    
maybe-name-value!
-                                                                    
decorate-source
-                                                                    
get-global-definition-hook
-                                                                    
put-global-definition-hook
-                                                                    session-id
-                                                                    
local-eval-hook
-                                                                    
top-level-eval-hook
-                                                                    fx<
-                                                                    fx=
-                                                                    fx-
-                                                                    fx+
-                                                                    
set-lambda-meta!
-                                                                    lambda-meta
-                                                                    lambda?
-                                                                    make-dynlet
-                                                                    make-letrec
-                                                                    make-let
-                                                                    
make-lambda-case
-                                                                    make-lambda
-                                                                    
make-sequence
-                                                                    
make-application
-                                                                    
make-conditional
-                                                                    
make-toplevel-define
-                                                                    
make-toplevel-set
-                                                                    
make-toplevel-ref
-                                                                    
make-module-set
-                                                                    
make-module-ref
-                                                                    
make-lexical-set
-                                                                    
make-lexical-ref
-                                                                    
make-primitive-ref
-                                                                    make-const
-                                                                    make-void)
-                                                                  ((top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top))
-                                                                  ("l-*-476"
-                                                                   "l-*-474"
-                                                                   "l-*-472"
-                                                                   "l-*-470"
-                                                                   "l-*-468"
-                                                                   "l-*-466"
-                                                                   "l-*-464"
-                                                                   "l-*-462"
-                                                                   "l-*-460"
-                                                                   "l-*-458"
-                                                                   "l-*-456"
-                                                                   "l-*-454"
-                                                                   "l-*-452"
-                                                                   "l-*-450"
-                                                                   "l-*-448"
-                                                                   "l-*-446"
-                                                                   "l-*-444"
-                                                                   "l-*-442"
-                                                                   "l-*-440"
-                                                                   "l-*-438"
-                                                                   "l-*-436"
-                                                                   "l-*-434"
-                                                                   "l-*-432"
-                                                                   "l-*-430"
-                                                                   "l-*-428"
-                                                                   "l-*-426"
-                                                                   "l-*-424"
-                                                                   "l-*-422"
-                                                                   "l-*-420"
-                                                                   "l-*-418"
-                                                                   "l-*-416"
-                                                                   "l-*-414"
-                                                                   "l-*-412"
-                                                                   "l-*-410"
-                                                                   "l-*-408"
-                                                                   "l-*-406"
-                                                                   "l-*-404"
-                                                                   "l-*-402"
-                                                                   "l-*-400"
-                                                                   "l-*-399"
-                                                                   "l-*-397"
-                                                                   "l-*-394"
-                                                                   "l-*-393"
-                                                                   "l-*-392"
-                                                                   "l-*-390"
-                                                                   "l-*-389"
-                                                                   "l-*-387"
-                                                                   "l-*-385"
-                                                                   "l-*-383"
-                                                                   "l-*-381"
-                                                                   "l-*-379"
-                                                                   "l-*-377"
-                                                                   "l-*-375"
-                                                                   "l-*-373"
-                                                                   "l-*-370"
-                                                                   "l-*-368"
-                                                                   "l-*-367"
-                                                                   "l-*-365"
-                                                                   "l-*-363"
-                                                                   "l-*-361"
-                                                                   "l-*-359"
-                                                                   "l-*-358"
-                                                                   "l-*-357"
-                                                                   "l-*-356"
-                                                                   "l-*-354"
-                                                                   "l-*-353"
-                                                                   "l-*-350"
-                                                                   "l-*-348"
-                                                                   "l-*-346"
-                                                                   "l-*-344"
-                                                                   "l-*-342"
-                                                                   "l-*-340"
-                                                                   "l-*-338"
-                                                                   "l-*-337"
-                                                                   "l-*-336"
-                                                                   "l-*-334"
-                                                                   "l-*-332"
-                                                                   "l-*-331"
-                                                                   "l-*-328"
-                                                                   "l-*-327"
-                                                                   "l-*-325"
-                                                                   "l-*-323"
-                                                                   "l-*-321"
-                                                                   "l-*-319"
-                                                                   "l-*-317"
-                                                                   "l-*-315"
-                                                                   "l-*-313"
-                                                                   "l-*-311"
-                                                                   "l-*-309"
-                                                                   "l-*-306"
-                                                                   "l-*-304"
-                                                                   "l-*-302"
-                                                                   "l-*-300"
-                                                                   "l-*-298"
-                                                                   "l-*-296"
-                                                                   "l-*-294"
-                                                                   "l-*-292"
-                                                                   "l-*-290"
-                                                                   "l-*-288"
-                                                                   "l-*-286"
-                                                                   "l-*-284"
-                                                                   "l-*-282"
-                                                                   "l-*-280"
-                                                                   "l-*-278"
-                                                                   "l-*-276"
-                                                                   "l-*-274"
-                                                                   "l-*-272"
-                                                                   "l-*-270"
-                                                                   "l-*-268"
-                                                                   "l-*-266"
-                                                                   "l-*-264"
-                                                                   "l-*-262"
-                                                                   "l-*-260"
-                                                                   "l-*-258"
-                                                                   "l-*-256"
-                                                                   "l-*-255"
-                                                                   "l-*-254"
-                                                                   "l-*-253"
-                                                                   "l-*-252"
-                                                                   "l-*-250"
-                                                                   "l-*-248"
-                                                                   "l-*-246"
-                                                                   "l-*-243"
-                                                                   "l-*-241"
-                                                                   "l-*-239"
-                                                                   "l-*-237"
-                                                                   "l-*-235"
-                                                                   "l-*-233"
-                                                                   "l-*-231"
-                                                                   "l-*-229"
-                                                                   "l-*-227"
-                                                                   "l-*-225"
-                                                                   "l-*-223"
-                                                                   "l-*-221"
-                                                                   "l-*-219"
-                                                                   "l-*-217"
-                                                                   "l-*-215"
-                                                                   "l-*-213"
-                                                                   "l-*-211"
-                                                                   "l-*-209"))
-                                                                #(ribcage
-                                                                  
(define-structure
-                                                                    
define-expansion-accessors
-                                                                    
define-expansion-constructors)
-                                                                  ((top)
-                                                                   (top)
-                                                                   (top))
-                                                                  ("l-*-47"
-                                                                   "l-*-46"
-                                                                   "l-*-45")))
-                                                               (hygiene
-                                                                 guile)))
-                                                          4)
-                                                     #t
-                                                     #f)
-                                                 '...
-                                                 '#(syntax-object
-                                                    ...
-                                                    ((top)
-                                                     #(ribcage () () ())
-                                                     #(ribcage () () ())
-                                                     #(ribcage
-                                                       #(x)
-                                                       #((top))
-                                                       #("l-*-2265"))
-                                                     #(ribcage
-                                                       (lambda-var-list
-                                                         gen-var
-                                                         strip
-                                                         expand-lambda-case
-                                                         lambda*-formals
-                                                         expand-simple-lambda
-                                                         lambda-formals
-                                                         ellipsis?
-                                                         expand-void
-                                                         eval-local-transformer
-                                                         expand-local-syntax
-                                                         expand-body
-                                                         expand-macro
-                                                         expand-application
-                                                         expand-expr
-                                                         expand
-                                                         syntax-type
-                                                         parse-when-list
-                                                         expand-install-global
-                                                         expand-top-sequence
-                                                         expand-sequence
-                                                         source-wrap
-                                                         wrap
-                                                         bound-id-member?
-                                                         distinct-bound-ids?
-                                                         valid-bound-ids?
-                                                         bound-id=?
-                                                         free-id=?
-                                                         
with-transformer-environment
-                                                         
transformer-environment
-                                                         resolve-identifier
-                                                         
locally-bound-identifiers
-                                                         id-var-name
-                                                         same-marks?
-                                                         join-marks
-                                                         join-wraps
-                                                         smart-append
-                                                         make-binding-wrap
-                                                         extend-ribcage!
-                                                         make-empty-ribcage
-                                                         new-mark
-                                                         anti-mark
-                                                         the-anti-mark
-                                                         top-marked?
-                                                         top-wrap
-                                                         empty-wrap
-                                                         set-ribcage-labels!
-                                                         set-ribcage-marks!
-                                                         set-ribcage-symnames!
-                                                         ribcage-labels
-                                                         ribcage-marks
-                                                         ribcage-symnames
-                                                         ribcage?
-                                                         make-ribcage
-                                                         gen-labels
-                                                         gen-label
-                                                         make-rename
-                                                         rename-marks
-                                                         rename-new
-                                                         rename-old
-                                                         subst-rename?
-                                                         wrap-subst
-                                                         wrap-marks
-                                                         make-wrap
-                                                         id-sym-name&marks
-                                                         id-sym-name
-                                                         id?
-                                                         nonsymbol-id?
-                                                         global-extend
-                                                         lookup
-                                                         macros-only-env
-                                                         extend-var-env
-                                                         extend-env
-                                                         null-env
-                                                         binding-value
-                                                         binding-type
-                                                         make-binding
-                                                         arg-check
-                                                         source-annotation
-                                                         no-source
-                                                         
set-syntax-object-module!
-                                                         
set-syntax-object-wrap!
-                                                         
set-syntax-object-expression!
-                                                         syntax-object-module
-                                                         syntax-object-wrap
-                                                         
syntax-object-expression
-                                                         syntax-object?
-                                                         make-syntax-object
-                                                         build-lexical-var
-                                                         build-letrec
-                                                         build-named-let
-                                                         build-let
-                                                         build-sequence
-                                                         build-data
-                                                         build-primref
-                                                         build-lambda-case
-                                                         build-case-lambda
-                                                         build-simple-lambda
-                                                         
build-global-definition
-                                                         
build-global-assignment
-                                                         build-global-reference
-                                                         analyze-variable
-                                                         
build-lexical-assignment
-                                                         
build-lexical-reference
-                                                         build-dynlet
-                                                         build-conditional
-                                                         build-application
-                                                         build-void
-                                                         maybe-name-value!
-                                                         decorate-source
-                                                         
get-global-definition-hook
-                                                         
put-global-definition-hook
-                                                         session-id
-                                                         local-eval-hook
-                                                         top-level-eval-hook
-                                                         fx<
-                                                         fx=
-                                                         fx-
-                                                         fx+
-                                                         set-lambda-meta!
-                                                         lambda-meta
-                                                         lambda?
-                                                         make-dynlet
-                                                         make-letrec
-                                                         make-let
-                                                         make-lambda-case
-                                                         make-lambda
-                                                         make-sequence
-                                                         make-application
-                                                         make-conditional
-                                                         make-toplevel-define
-                                                         make-toplevel-set
-                                                         make-toplevel-ref
-                                                         make-module-set
-                                                         make-module-ref
-                                                         make-lexical-set
-                                                         make-lexical-ref
-                                                         make-primitive-ref
-                                                         make-const
-                                                         make-void)
-                                                       ((top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top)
-                                                        (top))
-                                                       ("l-*-476"
-                                                        "l-*-474"
-                                                        "l-*-472"
-                                                        "l-*-470"
-                                                        "l-*-468"
-                                                        "l-*-466"
-                                                        "l-*-464"
-                                                        "l-*-462"
-                                                        "l-*-460"
-                                                        "l-*-458"
-                                                        "l-*-456"
-                                                        "l-*-454"
-                                                        "l-*-452"
-                                                        "l-*-450"
-                                                        "l-*-448"
-                                                        "l-*-446"
-                                                        "l-*-444"
-                                                        "l-*-442"
-                                                        "l-*-440"
-                                                        "l-*-438"
-                                                        "l-*-436"
-                                                        "l-*-434"
-                                                        "l-*-432"
-                                                        "l-*-430"
-                                                        "l-*-428"
-                                                        "l-*-426"
-                                                        "l-*-424"
-                                                        "l-*-422"
-                                                        "l-*-420"
-                                                        "l-*-418"
-                                                        "l-*-416"
-                                                        "l-*-414"
-                                                        "l-*-412"
-                                                        "l-*-410"
-                                                        "l-*-408"
-                                                        "l-*-406"
-                                                        "l-*-404"
-                                                        "l-*-402"
-                                                        "l-*-400"
-                                                        "l-*-399"
-                                                        "l-*-397"
-                                                        "l-*-394"
-                                                        "l-*-393"
-                                                        "l-*-392"
-                                                        "l-*-390"
-                                                        "l-*-389"
-                                                        "l-*-387"
-                                                        "l-*-385"
-                                                        "l-*-383"
-                                                        "l-*-381"
-                                                        "l-*-379"
-                                                        "l-*-377"
-                                                        "l-*-375"
-                                                        "l-*-373"
-                                                        "l-*-370"
-                                                        "l-*-368"
-                                                        "l-*-367"
-                                                        "l-*-365"
-                                                        "l-*-363"
-                                                        "l-*-361"
-                                                        "l-*-359"
-                                                        "l-*-358"
-                                                        "l-*-357"
-                                                        "l-*-356"
-                                                        "l-*-354"
-                                                        "l-*-353"
-                                                        "l-*-350"
-                                                        "l-*-348"
-                                                        "l-*-346"
-                                                        "l-*-344"
-                                                        "l-*-342"
-                                                        "l-*-340"
-                                                        "l-*-338"
-                                                        "l-*-337"
-                                                        "l-*-336"
-                                                        "l-*-334"
-                                                        "l-*-332"
-                                                        "l-*-331"
-                                                        "l-*-328"
-                                                        "l-*-327"
-                                                        "l-*-325"
-                                                        "l-*-323"
-                                                        "l-*-321"
-                                                        "l-*-319"
-                                                        "l-*-317"
-                                                        "l-*-315"
-                                                        "l-*-313"
-                                                        "l-*-311"
-                                                        "l-*-309"
-                                                        "l-*-306"
-                                                        "l-*-304"
-                                                        "l-*-302"
-                                                        "l-*-300"
-                                                        "l-*-298"
-                                                        "l-*-296"
-                                                        "l-*-294"
-                                                        "l-*-292"
-                                                        "l-*-290"
-                                                        "l-*-288"
-                                                        "l-*-286"
-                                                        "l-*-284"
-                                                        "l-*-282"
-                                                        "l-*-280"
-                                                        "l-*-278"
-                                                        "l-*-276"
-                                                        "l-*-274"
-                                                        "l-*-272"
-                                                        "l-*-270"
-                                                        "l-*-268"
-                                                        "l-*-266"
-                                                        "l-*-264"
-                                                        "l-*-262"
-                                                        "l-*-260"
-                                                        "l-*-258"
-                                                        "l-*-256"
-                                                        "l-*-255"
-                                                        "l-*-254"
-                                                        "l-*-253"
-                                                        "l-*-252"
-                                                        "l-*-250"
-                                                        "l-*-248"
-                                                        "l-*-246"
-                                                        "l-*-243"
-                                                        "l-*-241"
-                                                        "l-*-239"
-                                                        "l-*-237"
-                                                        "l-*-235"
-                                                        "l-*-233"
-                                                        "l-*-231"
-                                                        "l-*-229"
-                                                        "l-*-227"
-                                                        "l-*-225"
-                                                        "l-*-223"
-                                                        "l-*-221"
-                                                        "l-*-219"
-                                                        "l-*-217"
-                                                        "l-*-215"
-                                                        "l-*-213"
-                                                        "l-*-211"
-                                                        "l-*-209"))
-                                                     #(ribcage
-                                                       (define-structure
-                                                         
define-expansion-accessors
-                                                         
define-expansion-constructors)
-                                                       ((top) (top) (top))
-                                                       ("l-*-47"
-                                                        "l-*-46"
-                                                        "l-*-45")))
-                                                    (hygiene guile))))
-                                        (eq? (id-var-name-4280
-                                               dots-12352
-                                               '(()))
-                                             (id-var-name-4280
-                                               '#(syntax-object
-                                                  ...
-                                                  ((top)
-                                                   #(ribcage () () ())
-                                                   #(ribcage () () ())
-                                                   #(ribcage
-                                                     #(x)
-                                                     #((top))
-                                                     #("l-*-2265"))
-                                                   #(ribcage
-                                                     (lambda-var-list
-                                                       gen-var
-                                                       strip
-                                                       expand-lambda-case
-                                                       lambda*-formals
-                                                       expand-simple-lambda
-                                                       lambda-formals
-                                                       ellipsis?
-                                                       expand-void
-                                                       eval-local-transformer
-                                                       expand-local-syntax
-                                                       expand-body
-                                                       expand-macro
-                                                       expand-application
-                                                       expand-expr
-                                                       expand
-                                                       syntax-type
-                                                       parse-when-list
-                                                       expand-install-global
-                                                       expand-top-sequence
-                                                       expand-sequence
-                                                       source-wrap
-                                                       wrap
-                                                       bound-id-member?
-                                                       distinct-bound-ids?
-                                                       valid-bound-ids?
-                                                       bound-id=?
-                                                       free-id=?
-                                                       
with-transformer-environment
-                                                       transformer-environment
-                                                       resolve-identifier
-                                                       
locally-bound-identifiers
-                                                       id-var-name
-                                                       same-marks?
-                                                       join-marks
-                                                       join-wraps
-                                                       smart-append
-                                                       make-binding-wrap
-                                                       extend-ribcage!
-                                                       make-empty-ribcage
-                                                       new-mark
-                                                       anti-mark
-                                                       the-anti-mark
-                                                       top-marked?
-                                                       top-wrap
-                                                       empty-wrap
-                                                       set-ribcage-labels!
-                                                       set-ribcage-marks!
-                                                       set-ribcage-symnames!
-                                                       ribcage-labels
-                                                       ribcage-marks
-                                                       ribcage-symnames
-                                                       ribcage?
-                                                       make-ribcage
-                                                       gen-labels
-                                                       gen-label
-                                                       make-rename
-                                                       rename-marks
-                                                       rename-new
-                                                       rename-old
-                                                       subst-rename?
-                                                       wrap-subst
-                                                       wrap-marks
-                                                       make-wrap
-                                                       id-sym-name&marks
-                                                       id-sym-name
-                                                       id?
-                                                       nonsymbol-id?
-                                                       global-extend
-                                                       lookup
-                                                       macros-only-env
-                                                       extend-var-env
-                                                       extend-env
-                                                       null-env
-                                                       binding-value
-                                                       binding-type
-                                                       make-binding
-                                                       arg-check
-                                                       source-annotation
-                                                       no-source
-                                                       
set-syntax-object-module!
-                                                       set-syntax-object-wrap!
-                                                       
set-syntax-object-expression!
-                                                       syntax-object-module
-                                                       syntax-object-wrap
-                                                       syntax-object-expression
-                                                       syntax-object?
-                                                       make-syntax-object
-                                                       build-lexical-var
-                                                       build-letrec
-                                                       build-named-let
-                                                       build-let
-                                                       build-sequence
-                                                       build-data
-                                                       build-primref
-                                                       build-lambda-case
-                                                       build-case-lambda
-                                                       build-simple-lambda
-                                                       build-global-definition
-                                                       build-global-assignment
-                                                       build-global-reference
-                                                       analyze-variable
-                                                       build-lexical-assignment
-                                                       build-lexical-reference
-                                                       build-dynlet
-                                                       build-conditional
-                                                       build-application
-                                                       build-void
-                                                       maybe-name-value!
-                                                       decorate-source
-                                                       
get-global-definition-hook
-                                                       
put-global-definition-hook
-                                                       session-id
-                                                       local-eval-hook
-                                                       top-level-eval-hook
-                                                       fx<
-                                                       fx=
-                                                       fx-
-                                                       fx+
-                                                       set-lambda-meta!
-                                                       lambda-meta
-                                                       lambda?
-                                                       make-dynlet
-                                                       make-letrec
-                                                       make-let
-                                                       make-lambda-case
-                                                       make-lambda
-                                                       make-sequence
-                                                       make-application
-                                                       make-conditional
-                                                       make-toplevel-define
-                                                       make-toplevel-set
-                                                       make-toplevel-ref
-                                                       make-module-set
-                                                       make-module-ref
-                                                       make-lexical-set
-                                                       make-lexical-ref
-                                                       make-primitive-ref
-                                                       make-const
-                                                       make-void)
-                                                     ((top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top)
-                                                      (top))
-                                                     ("l-*-476"
-                                                      "l-*-474"
-                                                      "l-*-472"
-                                                      "l-*-470"
-                                                      "l-*-468"
-                                                      "l-*-466"
-                                                      "l-*-464"
-                                                      "l-*-462"
-                                                      "l-*-460"
-                                                      "l-*-458"
-                                                      "l-*-456"
-                                                      "l-*-454"
-                                                      "l-*-452"
-                                                      "l-*-450"
-                                                      "l-*-448"
-                                                      "l-*-446"
-                                                      "l-*-444"
-                                                      "l-*-442"
-                                                      "l-*-440"
-                                                      "l-*-438"
-                                                      "l-*-436"
-                                                      "l-*-434"
-                                                      "l-*-432"
-                                                      "l-*-430"
-                                                      "l-*-428"
-                                                      "l-*-426"
-                                                      "l-*-424"
-                                                      "l-*-422"
-                                                      "l-*-420"
-                                                      "l-*-418"
-                                                      "l-*-416"
-                                                      "l-*-414"
-                                                      "l-*-412"
-                                                      "l-*-410"
-                                                      "l-*-408"
-                                                      "l-*-406"
-                                                      "l-*-404"
-                                                      "l-*-402"
-                                                      "l-*-400"
-                                                      "l-*-399"
-                                                      "l-*-397"
-                                                      "l-*-394"
-                                                      "l-*-393"
-                                                      "l-*-392"
-                                                      "l-*-390"
-                                                      "l-*-389"
-                                                      "l-*-387"
-                                                      "l-*-385"
-                                                      "l-*-383"
-                                                      "l-*-381"
-                                                      "l-*-379"
-                                                      "l-*-377"
-                                                      "l-*-375"
-                                                      "l-*-373"
-                                                      "l-*-370"
-                                                      "l-*-368"
-                                                      "l-*-367"
-                                                      "l-*-365"
-                                                      "l-*-363"
-                                                      "l-*-361"
-                                                      "l-*-359"
-                                                      "l-*-358"
-                                                      "l-*-357"
-                                                      "l-*-356"
-                                                      "l-*-354"
-                                                      "l-*-353"
-                                                      "l-*-350"
-                                                      "l-*-348"
-                                                      "l-*-346"
-                                                      "l-*-344"
-                                                      "l-*-342"
-                                                      "l-*-340"
-                                                      "l-*-338"
-                                                      "l-*-337"
-                                                      "l-*-336"
-                                                      "l-*-334"
-                                                      "l-*-332"
-                                                      "l-*-331"
-                                                      "l-*-328"
-                                                      "l-*-327"
-                                                      "l-*-325"
-                                                      "l-*-323"
-                                                      "l-*-321"
-                                                      &qu