Import psyntax from Guile-1.8: R7RS with-ellipsis.
authorJan Nieuwenhuizen <janneke@gnu.org>
Mon, 19 Dec 2016 18:41:43 +0000 (19:41 +0100)
committerJan Nieuwenhuizen <janneke@gnu.org>
Mon, 19 Dec 2016 18:41:43 +0000 (19:41 +0100)
* GNUmakefile (psyntax-import): New target.
* module/mes/psyntax.ss: Import.
* module/mes/psyntax-pp.mes: Import.
* NEWS: Mention it.

GNUmakefile
NEWS
module/mes/psyntax-1.mes
module/mes/psyntax-pp.mes
module/mes/psyntax.ss
tests/psyntax.test

index 3b96a1f7e128674fd4da42fdc4e909fb6c6e8d6b..7623b603bf100f523507412a7e67d15262438a6e 100644 (file)
@@ -110,6 +110,11 @@ guile-mescc: mescc.cat
 paren: all
        scripts/paren.mes
 
+GUILE_GIT:=$(HOME)/src/guile
+psyntax-import:
+       git --git-dir=$(GUILE_GIT)/.git --work-tree=$(GUILE_GIT) show ba8a709:ice-9/psyntax.ss > module/mes/psyntax.ss
+       git --git-dir=$(GUILE_GIT)/.git --work-tree=$(GUILE_GIT) show ba8a709:ice-9/psyntax.pp > module/mes/psyntax-pp.mes
+
 help: help-top
 
 install: all
diff --git a/NEWS b/NEWS
index 621578b37f69f9ac9a018a3d35e1001f88166ab8..2946bd4a12d941d357e0533d3354a7f5209e3972 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -22,6 +22,7 @@ block-comments are all handled by the Scheme reader later.
 *** Lambda* and define* are now supported.
 *** #;-comment is now supported.
 *** Non-nested #| |#-comment is now supported.
+*** R7RS syntax-rules with custom ellipsis, with-ellipsis are now supported.
 ** Noteworthy bug fixes
 *** Closure is not a pair.
 * Changes in 0.3 since 0.2
index 11cb99a1dfdf582637daeed518e129ed12e7e088..cce7f8d39622c39e3446982e855879e4c47994e6 100644 (file)
@@ -28,8 +28,3 @@
 (define datum->syntax datum->syntax-object)
 (define syntax->datum syntax-object->datum)
 (set! expand-macro sc-expand)
-
-(define-macro (define-syntax-rule id-pattern . template)
-  `(define-syntax ,(car id-pattern)
-     (syntax-rules ()
-       ((,(car id-pattern) . ,(cdr id-pattern)) ,@template))))
index 88397dde27d047895153ad86db793f794fa84de6..f155f06887e3fb06aa66f875fbe27836ecd09492 100644 (file)
-;;; psyntax.pp
-;;; automatically generated from psyntax.ss
-;;; Mon Aug 18 13:18:06 EST 1997
-;;; see copyright notice in psyntax.ss
+(letrec ((syntmp-lambda-var-list-167
+           (lambda (syntmp-vars-552)
+             (let syntmp-lvl-553 ((syntmp-vars-554 syntmp-vars-552)
+                                  (syntmp-ls-555 (quote ()))
+                                  (syntmp-w-556 (quote (()))))
+               (cond ((pair? syntmp-vars-554)
+                      (syntmp-lvl-553
+                        (cdr syntmp-vars-554)
+                        (cons (syntmp-wrap-146
+                                (car syntmp-vars-554)
+                                syntmp-w-556)
+                              syntmp-ls-555)
+                        syntmp-w-556))
+                     ((syntmp-id?-118 syntmp-vars-554)
+                      (cons (syntmp-wrap-146 syntmp-vars-554 syntmp-w-556)
+                            syntmp-ls-555))
+                     ((null? syntmp-vars-554) syntmp-ls-555)
+                     ((syntmp-syntax-object?-104 syntmp-vars-554)
+                      (syntmp-lvl-553
+                        (syntmp-syntax-object-expression-105
+                          syntmp-vars-554)
+                        syntmp-ls-555
+                        (syntmp-join-wraps-137
+                          syntmp-w-556
+                          (syntmp-syntax-object-wrap-106 syntmp-vars-554))))
+                     ((syntmp-annotation?-92 syntmp-vars-554)
+                      (syntmp-lvl-553
+                        (annotation-expression syntmp-vars-554)
+                        syntmp-ls-555
+                        syntmp-w-556))
+                     (else (cons syntmp-vars-554 syntmp-ls-555))))))
+         (syntmp-gen-var-166
+           (lambda (syntmp-id-557)
+             (let ((syntmp-id-558
+                     (if (syntmp-syntax-object?-104 syntmp-id-557)
+                       (syntmp-syntax-object-expression-105
+                         syntmp-id-557)
+                       syntmp-id-557)))
+               (if (syntmp-annotation?-92 syntmp-id-558)
+                 (gensym
+                   (symbol->string
+                     (annotation-expression syntmp-id-558)))
+                 (gensym (symbol->string syntmp-id-558))))))
+         (syntmp-strip-165
+           (lambda (syntmp-x-559 syntmp-w-560)
+             (if (memq 'top
+                       (syntmp-wrap-marks-121 syntmp-w-560))
+               (if (or (syntmp-annotation?-92 syntmp-x-559)
+                       (and (pair? syntmp-x-559)
+                            (syntmp-annotation?-92 (car syntmp-x-559))))
+                 (syntmp-strip-annotation-164 syntmp-x-559 #f)
+                 syntmp-x-559)
+               (let syntmp-f-561 ((syntmp-x-562 syntmp-x-559))
+                 (cond ((syntmp-syntax-object?-104 syntmp-x-562)
+                        (syntmp-strip-165
+                          (syntmp-syntax-object-expression-105
+                            syntmp-x-562)
+                          (syntmp-syntax-object-wrap-106 syntmp-x-562)))
+                       ((pair? syntmp-x-562)
+                        (let ((syntmp-a-563 (syntmp-f-561 (car syntmp-x-562)))
+                              (syntmp-d-564 (syntmp-f-561 (cdr syntmp-x-562))))
+                          (if (and (eq? syntmp-a-563 (car syntmp-x-562))
+                                   (eq? syntmp-d-564 (cdr syntmp-x-562)))
+                            syntmp-x-562
+                            (cons syntmp-a-563 syntmp-d-564))))
+                       ((vector? syntmp-x-562)
+                        (let ((syntmp-old-565 (vector->list syntmp-x-562)))
+                          (let ((syntmp-new-566
+                                  (map syntmp-f-561 syntmp-old-565)))
+                            (if (andmap eq? syntmp-old-565 syntmp-new-566)
+                              syntmp-x-562
+                              (list->vector syntmp-new-566)))))
+                       (else syntmp-x-562))))))
+         (syntmp-strip-annotation-164
+           (lambda (syntmp-x-567 syntmp-parent-568)
+             (cond ((pair? syntmp-x-567)
+                    (let ((syntmp-new-569 (cons #f #f)))
+                      (begin
+                        (when syntmp-parent-568
+                              (set-annotation-stripped!
+                                syntmp-parent-568
+                                syntmp-new-569))
+                        (set-car!
+                          syntmp-new-569
+                          (syntmp-strip-annotation-164
+                            (car syntmp-x-567)
+                            #f))
+                        (set-cdr!
+                          syntmp-new-569
+                          (syntmp-strip-annotation-164
+                            (cdr syntmp-x-567)
+                            #f))
+                        syntmp-new-569)))
+                   ((syntmp-annotation?-92 syntmp-x-567)
+                    (or (annotation-stripped syntmp-x-567)
+                        (syntmp-strip-annotation-164
+                          (annotation-expression syntmp-x-567)
+                          syntmp-x-567)))
+                   ((vector? syntmp-x-567)
+                    (let ((syntmp-new-570
+                            (make-vector (vector-length syntmp-x-567))))
+                      (begin
+                        (when syntmp-parent-568
+                              (set-annotation-stripped!
+                                syntmp-parent-568
+                                syntmp-new-570))
+                        (let syntmp-loop-571 ((syntmp-i-572
+                                                (- (vector-length syntmp-x-567)
+                                                   1)))
+                          (unless
+                            (syntmp-fx<-91 syntmp-i-572 0)
+                            (vector-set!
+                              syntmp-new-570
+                              syntmp-i-572
+                              (syntmp-strip-annotation-164
+                                (vector-ref syntmp-x-567 syntmp-i-572)
+                                #f))
+                            (syntmp-loop-571 (syntmp-fx--89 syntmp-i-572 1))))
+                        syntmp-new-570)))
+                   (else syntmp-x-567))))
+         (syntmp-ellipsis?-163
+           (lambda (syntmp-e-573 syntmp-r-574)
+             (and (syntmp-nonsymbol-id?-117 syntmp-e-573)
+                  (let ((syntmp-id-575
+                          (syntmp-make-syntax-object-103
+                            '$sc-ellipsis
+                            (syntmp-syntax-object-wrap-106 syntmp-e-573))))
+                    (let ((syntmp-n-576
+                            (syntmp-id-var-name-140
+                              syntmp-id-575
+                              '(()))))
+                      (let ((syntmp-b-577
+                              (syntmp-lookup-115 syntmp-n-576 syntmp-r-574)))
+                        (if (eq? (syntmp-binding-type-110 syntmp-b-577)
+                                 'ellipsis)
+                          (syntmp-bound-id=?-142
+                            syntmp-e-573
+                            (syntmp-binding-value-111 syntmp-b-577))
+                          (syntmp-free-id=?-141
+                            syntmp-e-573
+                            '#(syntax-object
+                               ...
+                               ((top)
+                                #(ribcage () () ())
+                                #(ribcage () () ())
+                                #(ribcage #(b) #((top)) #("i"))
+                                #(ribcage () () ())
+                                #(ribcage #(n) #((top)) #("i"))
+                                #(ribcage () () ())
+                                #(ribcage #(id) #((top)) #("i"))
+                                #(ribcage () () ())
+                                #(ribcage #(e r) #((top) (top)) #("i" "i"))
+                                #(ribcage
+                                  (lambda-var-list
+                                    gen-var
+                                    strip
+                                    strip-annotation
+                                    ellipsis?
+                                    chi-void
+                                    eval-local-transformer
+                                    chi-local-syntax
+                                    chi-lambda-clause
+                                    chi-body
+                                    chi-macro
+                                    chi-application
+                                    chi-expr
+                                    chi
+                                    chi-top
+                                    syntax-type
+                                    chi-when-list
+                                    chi-install-global
+                                    chi-top-sequence
+                                    chi-sequence
+                                    source-wrap
+                                    wrap
+                                    bound-id-member?
+                                    distinct-bound-ids?
+                                    valid-bound-ids?
+                                    bound-id=?
+                                    free-id=?
+                                    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
+                                    unannotate
+                                    set-syntax-object-wrap!
+                                    set-syntax-object-expression!
+                                    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
+                                    build-global-definition
+                                    build-global-assignment
+                                    build-global-reference
+                                    build-lexical-assignment
+                                    build-lexical-reference
+                                    build-conditional
+                                    build-application
+                                    get-global-definition-hook
+                                    put-global-definition-hook
+                                    gensym-hook
+                                    error-hook
+                                    local-eval-hook
+                                    top-level-eval-hook
+                                    annotation?
+                                    fx<
+                                    fx=
+                                    fx-
+                                    fx+
+                                    noexpand)
+                                  ((top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top)
+                                   (top))
+                                  ("i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"
+                                   "i"))
+                                #(ribcage
+                                  (define-structure)
+                                  ((top))
+                                  ("i"))))))))))))
+         (syntmp-chi-void-162
+           (lambda () (list (quote void))))
+         (syntmp-eval-local-transformer-161
+           (lambda (syntmp-expanded-578)
+             (let ((syntmp-p-579
+                     (syntmp-local-eval-hook-94 syntmp-expanded-578)))
+               (if (procedure? syntmp-p-579)
+                 syntmp-p-579
+                 (syntax-error
+                   syntmp-p-579
+                   "nonprocedure transformer")))))
+         (syntmp-chi-local-syntax-160
+           (lambda (syntmp-rec?-580
+                    syntmp-e-581
+                    syntmp-r-582
+                    syntmp-w-583
+                    syntmp-s-584
+                    syntmp-k-585)
+             ((lambda (syntmp-tmp-586)
+                ((lambda (syntmp-tmp-587)
+                   (if syntmp-tmp-587
+                     (apply (lambda (syntmp-_-588
+                                     syntmp-id-589
+                                     syntmp-val-590
+                                     syntmp-e1-591
+                                     syntmp-e2-592)
+                              (let ((syntmp-ids-593 syntmp-id-589))
+                                (if (not (syntmp-valid-bound-ids?-143
+                                           syntmp-ids-593))
+                                  (syntax-error
+                                    syntmp-e-581
+                                    "duplicate bound keyword in")
+                                  (let ((syntmp-labels-595
+                                          (syntmp-gen-labels-124
+                                            syntmp-ids-593)))
+                                    (let ((syntmp-new-w-596
+                                            (syntmp-make-binding-wrap-135
+                                              syntmp-ids-593
+                                              syntmp-labels-595
+                                              syntmp-w-583)))
+                                      (syntmp-k-585
+                                        (cons syntmp-e1-591 syntmp-e2-592)
+                                        (syntmp-extend-env-112
+                                          syntmp-labels-595
+                                          (let ((syntmp-w-598
+                                                  (if syntmp-rec?-580
+                                                    syntmp-new-w-596
+                                                    syntmp-w-583))
+                                                (syntmp-trans-r-599
+                                                  (syntmp-macros-only-env-114
+                                                    syntmp-r-582)))
+                                            (map (lambda (syntmp-x-600)
+                                                   (cons 'macro
+                                                         (syntmp-eval-local-transformer-161
+                                                           (syntmp-chi-154
+                                                             syntmp-x-600
+                                                             syntmp-trans-r-599
+                                                             syntmp-w-598))))
+                                                 syntmp-val-590))
+                                          syntmp-r-582)
+                                        syntmp-new-w-596
+                                        syntmp-s-584))))))
+                            syntmp-tmp-587)
+                     ((lambda (syntmp-_-602)
+                        (syntax-error
+                          (syntmp-source-wrap-147
+                            syntmp-e-581
+                            syntmp-w-583
+                            syntmp-s-584)))
+                      syntmp-tmp-586)))
+                 (syntax-dispatch
+                   syntmp-tmp-586
+                   '(any #(each (any any)) any . each-any))))
+              syntmp-e-581)))
+         (syntmp-chi-lambda-clause-159
+           (lambda (syntmp-e-603
+                    syntmp-c-604
+                    syntmp-r-605
+                    syntmp-w-606
+                    syntmp-k-607)
+             ((lambda (syntmp-tmp-608)
+                ((lambda (syntmp-tmp-609)
+                   (if syntmp-tmp-609
+                     (apply (lambda (syntmp-id-610 syntmp-e1-611 syntmp-e2-612)
+                              (let ((syntmp-ids-613 syntmp-id-610))
+                                (if (not (syntmp-valid-bound-ids?-143
+                                           syntmp-ids-613))
+                                  (syntax-error
+                                    syntmp-e-603
+                                    "invalid parameter list in")
+                                  (let ((syntmp-labels-615
+                                          (syntmp-gen-labels-124
+                                            syntmp-ids-613))
+                                        (syntmp-new-vars-616
+                                          (map syntmp-gen-var-166
+                                               syntmp-ids-613)))
+                                    (syntmp-k-607
+                                      syntmp-new-vars-616
+                                      (syntmp-chi-body-158
+                                        (cons syntmp-e1-611 syntmp-e2-612)
+                                        syntmp-e-603
+                                        (syntmp-extend-var-env-113
+                                          syntmp-labels-615
+                                          syntmp-new-vars-616
+                                          syntmp-r-605)
+                                        (syntmp-make-binding-wrap-135
+                                          syntmp-ids-613
+                                          syntmp-labels-615
+                                          syntmp-w-606)))))))
+                            syntmp-tmp-609)
+                     ((lambda (syntmp-tmp-618)
+                        (if syntmp-tmp-618
+                          (apply (lambda (syntmp-ids-619
+                                          syntmp-e1-620
+                                          syntmp-e2-621)
+                                   (let ((syntmp-old-ids-622
+                                           (syntmp-lambda-var-list-167
+                                             syntmp-ids-619)))
+                                     (if (not (syntmp-valid-bound-ids?-143
+                                                syntmp-old-ids-622))
+                                       (syntax-error
+                                         syntmp-e-603
+                                         "invalid parameter list in")
+                                       (let ((syntmp-labels-623
+                                               (syntmp-gen-labels-124
+                                                 syntmp-old-ids-622))
+                                             (syntmp-new-vars-624
+                                               (map syntmp-gen-var-166
+                                                    syntmp-old-ids-622)))
+                                         (syntmp-k-607
+                                           (let syntmp-f-625 ((syntmp-ls1-626
+                                                                (cdr syntmp-new-vars-624))
+                                                              (syntmp-ls2-627
+                                                                (car syntmp-new-vars-624)))
+                                             (if (null? syntmp-ls1-626)
+                                               syntmp-ls2-627
+                                               (syntmp-f-625
+                                                 (cdr syntmp-ls1-626)
+                                                 (cons (car syntmp-ls1-626)
+                                                       syntmp-ls2-627))))
+                                           (syntmp-chi-body-158
+                                             (cons syntmp-e1-620 syntmp-e2-621)
+                                             syntmp-e-603
+                                             (syntmp-extend-var-env-113
+                                               syntmp-labels-623
+                                               syntmp-new-vars-624
+                                               syntmp-r-605)
+                                             (syntmp-make-binding-wrap-135
+                                               syntmp-old-ids-622
+                                               syntmp-labels-623
+                                               syntmp-w-606)))))))
+                                 syntmp-tmp-618)
+                          ((lambda (syntmp-_-629)
+                             (syntax-error syntmp-e-603))
+                           syntmp-tmp-608)))
+                      (syntax-dispatch
+                        syntmp-tmp-608
+                        '(any any . each-any)))))
+                 (syntax-dispatch
+                   syntmp-tmp-608
+                   '(each-any any . each-any))))
+              syntmp-c-604)))
+         (syntmp-chi-body-158
+           (lambda (syntmp-body-630
+                    syntmp-outer-form-631
+                    syntmp-r-632
+                    syntmp-w-633)
+             (let ((syntmp-r-634
+                     (cons '("placeholder" placeholder)
+                           syntmp-r-632)))
+               (let ((syntmp-ribcage-635
+                       (syntmp-make-ribcage-125
+                         '()
+                         '()
+                         '())))
+                 (let ((syntmp-w-636
+                         (syntmp-make-wrap-120
+                           (syntmp-wrap-marks-121 syntmp-w-633)
+                           (cons syntmp-ribcage-635
+                                 (syntmp-wrap-subst-122 syntmp-w-633)))))
+                   (let syntmp-parse-637 ((syntmp-body-638
+                                            (map (lambda (syntmp-x-644)
+                                                   (cons syntmp-r-634
+                                                         (syntmp-wrap-146
+                                                           syntmp-x-644
+                                                           syntmp-w-636)))
+                                                 syntmp-body-630))
+                                          (syntmp-ids-639 (quote ()))
+                                          (syntmp-labels-640 (quote ()))
+                                          (syntmp-vars-641 (quote ()))
+                                          (syntmp-vals-642 (quote ()))
+                                          (syntmp-bindings-643 (quote ())))
+                     (if (null? syntmp-body-638)
+                       (syntax-error
+                         syntmp-outer-form-631
+                         "no expressions in body")
+                       (let ((syntmp-e-645 (cdar syntmp-body-638))
+                             (syntmp-er-646 (caar syntmp-body-638)))
+                         (call-with-values
+                           (lambda ()
+                             (syntmp-syntax-type-152
+                               syntmp-e-645
+                               syntmp-er-646
+                               '(())
+                               #f
+                               syntmp-ribcage-635))
+                           (lambda (syntmp-type-647
+                                    syntmp-value-648
+                                    syntmp-e-649
+                                    syntmp-w-650
+                                    syntmp-s-651)
+                             (let ((syntmp-t-652 syntmp-type-647))
+                               (if (memv syntmp-t-652 (quote (define-form)))
+                                 (let ((syntmp-id-653
+                                         (syntmp-wrap-146
+                                           syntmp-value-648
+                                           syntmp-w-650))
+                                       (syntmp-label-654
+                                         (syntmp-gen-label-123)))
+                                   (let ((syntmp-var-655
+                                           (syntmp-gen-var-166 syntmp-id-653)))
+                                     (begin
+                                       (syntmp-extend-ribcage!-134
+                                         syntmp-ribcage-635
+                                         syntmp-id-653
+                                         syntmp-label-654)
+                                       (syntmp-parse-637
+                                         (cdr syntmp-body-638)
+                                         (cons syntmp-id-653 syntmp-ids-639)
+                                         (cons syntmp-label-654
+                                               syntmp-labels-640)
+                                         (cons syntmp-var-655 syntmp-vars-641)
+                                         (cons (cons syntmp-er-646
+                                                     (syntmp-wrap-146
+                                                       syntmp-e-649
+                                                       syntmp-w-650))
+                                               syntmp-vals-642)
+                                         (cons (cons 'lexical
+                                                     syntmp-var-655)
+                                               syntmp-bindings-643)))))
+                                 (if (memv syntmp-t-652
+                                           '(define-syntax-form))
+                                   (let ((syntmp-id-656
+                                           (syntmp-wrap-146
+                                             syntmp-value-648
+                                             syntmp-w-650))
+                                         (syntmp-label-657
+                                           (syntmp-gen-label-123)))
+                                     (begin
+                                       (syntmp-extend-ribcage!-134
+                                         syntmp-ribcage-635
+                                         syntmp-id-656
+                                         syntmp-label-657)
+                                       (syntmp-parse-637
+                                         (cdr syntmp-body-638)
+                                         (cons syntmp-id-656 syntmp-ids-639)
+                                         (cons syntmp-label-657
+                                               syntmp-labels-640)
+                                         syntmp-vars-641
+                                         syntmp-vals-642
+                                         (cons (cons 'macro
+                                                     (cons syntmp-er-646
+                                                           (syntmp-wrap-146
+                                                             syntmp-e-649
+                                                             syntmp-w-650)))
+                                               syntmp-bindings-643))))
+                                   (if (memv syntmp-t-652 (quote (begin-form)))
+                                     ((lambda (syntmp-tmp-658)
+                                        ((lambda (syntmp-tmp-659)
+                                           (if syntmp-tmp-659
+                                             (apply (lambda (syntmp-_-660
+                                                             syntmp-e1-661)
+                                                      (syntmp-parse-637
+                                                        (let syntmp-f-662 ((syntmp-forms-663
+                                                                             syntmp-e1-661))
+                                                          (if (null? syntmp-forms-663)
+                                                            (cdr syntmp-body-638)
+                                                            (cons (cons syntmp-er-646
+                                                                        (syntmp-wrap-146
+                                                                          (car syntmp-forms-663)
+                                                                          syntmp-w-650))
+                                                                  (syntmp-f-662
+                                                                    (cdr syntmp-forms-663)))))
+                                                        syntmp-ids-639
+                                                        syntmp-labels-640
+                                                        syntmp-vars-641
+                                                        syntmp-vals-642
+                                                        syntmp-bindings-643))
+                                                    syntmp-tmp-659)
+                                             (syntax-error syntmp-tmp-658)))
+                                         (syntax-dispatch
+                                           syntmp-tmp-658
+                                           '(any . each-any))))
+                                      syntmp-e-649)
+                                     (if (memv syntmp-t-652
+                                               '(local-syntax-form))
+                                       (syntmp-chi-local-syntax-160
+                                         syntmp-value-648
+                                         syntmp-e-649
+                                         syntmp-er-646
+                                         syntmp-w-650
+                                         syntmp-s-651
+                                         (lambda (syntmp-forms-665
+                                                  syntmp-er-666
+                                                  syntmp-w-667
+                                                  syntmp-s-668)
+                                           (syntmp-parse-637
+                                             (let syntmp-f-669 ((syntmp-forms-670
+                                                                  syntmp-forms-665))
+                                               (if (null? syntmp-forms-670)
+                                                 (cdr syntmp-body-638)
+                                                 (cons (cons syntmp-er-666
+                                                             (syntmp-wrap-146
+                                                               (car syntmp-forms-670)
+                                                               syntmp-w-667))
+                                                       (syntmp-f-669
+                                                         (cdr syntmp-forms-670)))))
+                                             syntmp-ids-639
+                                             syntmp-labels-640
+                                             syntmp-vars-641
+                                             syntmp-vals-642
+                                             syntmp-bindings-643)))
+                                       (if (null? syntmp-ids-639)
+                                         (syntmp-build-sequence-99
+                                           #f
+                                           (map (lambda (syntmp-x-671)
+                                                  (syntmp-chi-154
+                                                    (cdr syntmp-x-671)
+                                                    (car syntmp-x-671)
+                                                    '(())))
+                                                (cons (cons syntmp-er-646
+                                                            (syntmp-source-wrap-147
+                                                              syntmp-e-649
+                                                              syntmp-w-650
+                                                              syntmp-s-651))
+                                                      (cdr syntmp-body-638))))
+                                         (begin
+                                           (if (not (syntmp-valid-bound-ids?-143
+                                                      syntmp-ids-639))
+                                             (syntax-error
+                                               syntmp-outer-form-631
+                                               "invalid or duplicate identifier in definition"))
+                                           (let syntmp-loop-672 ((syntmp-bs-673
+                                                                   syntmp-bindings-643)
+                                                                 (syntmp-er-cache-674
+                                                                   #f)
+                                                                 (syntmp-r-cache-675
+                                                                   #f))
+                                             (if (not (null? syntmp-bs-673))
+                                               (let ((syntmp-b-676
+                                                       (car syntmp-bs-673)))
+                                                 (if (eq? (car syntmp-b-676)
+                                                          'macro)
+                                                   (let ((syntmp-er-677
+                                                           (cadr syntmp-b-676)))
+                                                     (let ((syntmp-r-cache-678
+                                                             (if (eq? syntmp-er-677
+                                                                      syntmp-er-cache-674)
+                                                               syntmp-r-cache-675
+                                                               (syntmp-macros-only-env-114
+                                                                 syntmp-er-677))))
+                                                       (begin
+                                                         (set-cdr!
+                                                           syntmp-b-676
+                                                           (syntmp-eval-local-transformer-161
+                                                             (syntmp-chi-154
+                                                               (cddr syntmp-b-676)
+                                                               syntmp-r-cache-678
+                                                               '(()))))
+                                                         (syntmp-loop-672
+                                                           (cdr syntmp-bs-673)
+                                                           syntmp-er-677
+                                                           syntmp-r-cache-678))))
+                                                   (syntmp-loop-672
+                                                     (cdr syntmp-bs-673)
+                                                     syntmp-er-cache-674
+                                                     syntmp-r-cache-675)))))
+                                           (set-cdr!
+                                             syntmp-r-634
+                                             (syntmp-extend-env-112
+                                               syntmp-labels-640
+                                               syntmp-bindings-643
+                                               (cdr syntmp-r-634)))
+                                           (syntmp-build-letrec-102
+                                             #f
+                                             syntmp-vars-641
+                                             (map (lambda (syntmp-x-679)
+                                                    (syntmp-chi-154
+                                                      (cdr syntmp-x-679)
+                                                      (car syntmp-x-679)
+                                                      '(())))
+                                                  syntmp-vals-642)
+                                             (syntmp-build-sequence-99
+                                               #f
+                                               (map (lambda (syntmp-x-680)
+                                                      (syntmp-chi-154
+                                                        (cdr syntmp-x-680)
+                                                        (car syntmp-x-680)
+                                                        '(())))
+                                                    (cons (cons syntmp-er-646
+                                                                (syntmp-source-wrap-147
+                                                                  syntmp-e-649
+                                                                  syntmp-w-650
+                                                                  syntmp-s-651))
+                                                          (cdr syntmp-body-638))))))))))))))))))))))
+         (syntmp-chi-macro-157
+           (lambda (syntmp-p-681
+                    syntmp-e-682
+                    syntmp-r-683
+                    syntmp-w-684
+                    syntmp-rib-685)
+             (letrec ((syntmp-rebuild-macro-output-686
+                        (lambda (syntmp-x-687 syntmp-m-688)
+                          (cond ((pair? syntmp-x-687)
+                                 (cons (syntmp-rebuild-macro-output-686
+                                         (car syntmp-x-687)
+                                         syntmp-m-688)
+                                       (syntmp-rebuild-macro-output-686
+                                         (cdr syntmp-x-687)
+                                         syntmp-m-688)))
+                                ((syntmp-syntax-object?-104 syntmp-x-687)
+                                 (let ((syntmp-w-689
+                                         (syntmp-syntax-object-wrap-106
+                                           syntmp-x-687)))
+                                   (let ((syntmp-ms-690
+                                           (syntmp-wrap-marks-121
+                                             syntmp-w-689))
+                                         (syntmp-s-691
+                                           (syntmp-wrap-subst-122
+                                             syntmp-w-689)))
+                                     (syntmp-make-syntax-object-103
+                                       (syntmp-syntax-object-expression-105
+                                         syntmp-x-687)
+                                       (if (and (pair? syntmp-ms-690)
+                                                (eq? (car syntmp-ms-690) #f))
+                                         (syntmp-make-wrap-120
+                                           (cdr syntmp-ms-690)
+                                           (if syntmp-rib-685
+                                             (cons syntmp-rib-685
+                                                   (cdr syntmp-s-691))
+                                             (cdr syntmp-s-691)))
+                                         (syntmp-make-wrap-120
+                                           (cons syntmp-m-688 syntmp-ms-690)
+                                           (if syntmp-rib-685
+                                             (cons syntmp-rib-685
+                                                   (cons 'shift
+                                                         syntmp-s-691))
+                                             (cons 'shift
+                                                   syntmp-s-691))))))))
+                                ((vector? syntmp-x-687)
+                                 (let ((syntmp-n-692
+                                         (vector-length syntmp-x-687)))
+                                   (let ((syntmp-v-693
+                                           (make-vector syntmp-n-692)))
+                                     (let syntmp-doloop-694 ((syntmp-i-695 0))
+                                       (if (syntmp-fx=-90
+                                             syntmp-i-695
+                                             syntmp-n-692)
+                                         syntmp-v-693
+                                         (begin
+                                           (vector-set!
+                                             syntmp-v-693
+                                             syntmp-i-695
+                                             (syntmp-rebuild-macro-output-686
+                                               (vector-ref
+                                                 syntmp-x-687
+                                                 syntmp-i-695)
+                                               syntmp-m-688))
+                                           (syntmp-doloop-694
+                                             (syntmp-fx+-88
+                                               syntmp-i-695
+                                               1))))))))
+                                ((symbol? syntmp-x-687)
+                                 (syntax-error
+                                   syntmp-x-687
+                                   "encountered raw symbol in macro output"))
+                                (else syntmp-x-687)))))
+               (syntmp-rebuild-macro-output-686
+                 (syntmp-p-681
+                   (syntmp-wrap-146
+                     syntmp-e-682
+                     (syntmp-anti-mark-133 syntmp-w-684)))
+                 (string #\m)))))
+         (syntmp-chi-application-156
+           (lambda (syntmp-x-696
+                    syntmp-e-697
+                    syntmp-r-698
+                    syntmp-w-699
+                    syntmp-s-700)
+             ((lambda (syntmp-tmp-701)
+                ((lambda (syntmp-tmp-702)
+                   (if syntmp-tmp-702
+                     (apply (lambda (syntmp-e0-703 syntmp-e1-704)
+                              (cons syntmp-x-696
+                                    (map (lambda (syntmp-e-705)
+                                           (syntmp-chi-154
+                                             syntmp-e-705
+                                             syntmp-r-698
+                                             syntmp-w-699))
+                                         syntmp-e1-704)))
+                            syntmp-tmp-702)
+                     (syntax-error syntmp-tmp-701)))
+                 (syntax-dispatch
+                   syntmp-tmp-701
+                   '(any . each-any))))
+              syntmp-e-697)))
+         (syntmp-chi-expr-155
+           (lambda (syntmp-type-707
+                    syntmp-value-708
+                    syntmp-e-709
+                    syntmp-r-710
+                    syntmp-w-711
+                    syntmp-s-712)
+             (let ((syntmp-t-713 syntmp-type-707))
+               (if (memv syntmp-t-713 (quote (lexical)))
+                 syntmp-value-708
+                 (if (memv syntmp-t-713 (quote (core external-macro)))
+                   (syntmp-value-708
+                     syntmp-e-709
+                     syntmp-r-710
+                     syntmp-w-711
+                     syntmp-s-712)
+                   (if (memv syntmp-t-713 (quote (lexical-call)))
+                     (syntmp-chi-application-156
+                       syntmp-value-708
+                       syntmp-e-709
+                       syntmp-r-710
+                       syntmp-w-711
+                       syntmp-s-712)
+                     (if (memv syntmp-t-713 (quote (global-call)))
+                       (syntmp-chi-application-156
+                         syntmp-value-708
+                         syntmp-e-709
+                         syntmp-r-710
+                         syntmp-w-711
+                         syntmp-s-712)
+                       (if (memv syntmp-t-713 (quote (constant)))
+                         (syntmp-build-data-98
+                           syntmp-s-712
+                           (syntmp-strip-165
+                             (syntmp-source-wrap-147
+                               syntmp-e-709
+                               syntmp-w-711
+                               syntmp-s-712)
+                             '(())))
+                         (if (memv syntmp-t-713 (quote (global)))
+                           syntmp-value-708
+                           (if (memv syntmp-t-713 (quote (call)))
+                             (syntmp-chi-application-156
+                               (syntmp-chi-154
+                                 (car syntmp-e-709)
+                                 syntmp-r-710
+                                 syntmp-w-711)
+                               syntmp-e-709
+                               syntmp-r-710
+                               syntmp-w-711
+                               syntmp-s-712)
+                             (if (memv syntmp-t-713 (quote (begin-form)))
+                               ((lambda (syntmp-tmp-714)
+                                  ((lambda (syntmp-tmp-715)
+                                     (if syntmp-tmp-715
+                                       (apply (lambda (syntmp-_-716
+                                                       syntmp-e1-717
+                                                       syntmp-e2-718)
+                                                (syntmp-chi-sequence-148
+                                                  (cons syntmp-e1-717
+                                                        syntmp-e2-718)
+                                                  syntmp-r-710
+                                                  syntmp-w-711
+                                                  syntmp-s-712))
+                                              syntmp-tmp-715)
+                                       (syntax-error syntmp-tmp-714)))
+                                   (syntax-dispatch
+                                     syntmp-tmp-714
+                                     '(any any . each-any))))
+                                syntmp-e-709)
+                               (if (memv syntmp-t-713
+                                         '(local-syntax-form))
+                                 (syntmp-chi-local-syntax-160
+                                   syntmp-value-708
+                                   syntmp-e-709
+                                   syntmp-r-710
+                                   syntmp-w-711
+                                   syntmp-s-712
+                                   syntmp-chi-sequence-148)
+                                 (if (memv syntmp-t-713
+                                           '(eval-when-form))
+                                   ((lambda (syntmp-tmp-720)
+                                      ((lambda (syntmp-tmp-721)
+                                         (if syntmp-tmp-721
+                                           (apply (lambda (syntmp-_-722
+                                                           syntmp-x-723
+                                                           syntmp-e1-724
+                                                           syntmp-e2-725)
+                                                    (let ((syntmp-when-list-726
+                                                            (syntmp-chi-when-list-151
+                                                              syntmp-e-709
+                                                              syntmp-x-723
+                                                              syntmp-w-711)))
+                                                      (if (memq 'eval
+                                                                syntmp-when-list-726)
+                                                        (syntmp-chi-sequence-148
+                                                          (cons syntmp-e1-724
+                                                                syntmp-e2-725)
+                                                          syntmp-r-710
+                                                          syntmp-w-711
+                                                          syntmp-s-712)
+                                                        (syntmp-chi-void-162))))
+                                                  syntmp-tmp-721)
+                                           (syntax-error syntmp-tmp-720)))
+                                       (syntax-dispatch
+                                         syntmp-tmp-720
+                                         '(any each-any any . each-any))))
+                                    syntmp-e-709)
+                                   (if (memv syntmp-t-713
+                                             '(define-form define-syntax-form))
+                                     (syntax-error
+                                       (syntmp-wrap-146
+                                         syntmp-value-708
+                                         syntmp-w-711)
+                                       "invalid context for definition of")
+                                     (if (memv syntmp-t-713 (quote (syntax)))
+                                       (syntax-error
+                                         (syntmp-source-wrap-147
+                                           syntmp-e-709
+                                           syntmp-w-711
+                                           syntmp-s-712)
+                                         "reference to pattern variable outside syntax form")
+                                       (if (memv syntmp-t-713
+                                                 '(displaced-lexical))
+                                         (syntax-error
+                                           (syntmp-source-wrap-147
+                                             syntmp-e-709
+                                             syntmp-w-711
+                                             syntmp-s-712)
+                                           "reference to identifier outside its scope")
+                                         (syntax-error
+                                           (syntmp-source-wrap-147
+                                             syntmp-e-709
+                                             syntmp-w-711
+                                             syntmp-s-712))))))))))))))))))
+         (syntmp-chi-154
+           (lambda (syntmp-e-729 syntmp-r-730 syntmp-w-731)
+             (call-with-values
+               (lambda ()
+                 (syntmp-syntax-type-152
+                   syntmp-e-729
+                   syntmp-r-730
+                   syntmp-w-731
+                   #f
+                   #f))
+               (lambda (syntmp-type-732
+                        syntmp-value-733
+                        syntmp-e-734
+                        syntmp-w-735
+                        syntmp-s-736)
+                 (syntmp-chi-expr-155
+                   syntmp-type-732
+                   syntmp-value-733
+                   syntmp-e-734
+                   syntmp-r-730
+                   syntmp-w-735
+                   syntmp-s-736)))))
+         (syntmp-chi-top-153
+           (lambda (syntmp-e-737
+                    syntmp-r-738
+                    syntmp-w-739
+                    syntmp-m-740
+                    syntmp-esew-741)
+             (call-with-values
+               (lambda ()
+                 (syntmp-syntax-type-152
+                   syntmp-e-737
+                   syntmp-r-738
+                   syntmp-w-739
+                   #f
+                   #f))
+               (lambda (syntmp-type-754
+                        syntmp-value-755
+                        syntmp-e-756
+                        syntmp-w-757
+                        syntmp-s-758)
+                 (let ((syntmp-t-759 syntmp-type-754))
+                   (if (memv syntmp-t-759 (quote (begin-form)))
+                     ((lambda (syntmp-tmp-760)
+                        ((lambda (syntmp-tmp-761)
+                           (if syntmp-tmp-761
+                             (apply (lambda (syntmp-_-762)
+                                      (syntmp-chi-void-162))
+                                    syntmp-tmp-761)
+                             ((lambda (syntmp-tmp-763)
+                                (if syntmp-tmp-763
+                                  (apply (lambda (syntmp-_-764
+                                                  syntmp-e1-765
+                                                  syntmp-e2-766)
+                                           (syntmp-chi-top-sequence-149
+                                             (cons syntmp-e1-765 syntmp-e2-766)
+                                             syntmp-r-738
+                                             syntmp-w-757
+                                             syntmp-s-758
+                                             syntmp-m-740
+                                             syntmp-esew-741))
+                                         syntmp-tmp-763)
+                                  (syntax-error syntmp-tmp-760)))
+                              (syntax-dispatch
+                                syntmp-tmp-760
+                                '(any any . each-any)))))
+                         (syntax-dispatch syntmp-tmp-760 (quote (any)))))
+                      syntmp-e-756)
+                     (if (memv syntmp-t-759 (quote (local-syntax-form)))
+                       (syntmp-chi-local-syntax-160
+                         syntmp-value-755
+                         syntmp-e-756
+                         syntmp-r-738
+                         syntmp-w-757
+                         syntmp-s-758
+                         (lambda (syntmp-body-768
+                                  syntmp-r-769
+                                  syntmp-w-770
+                                  syntmp-s-771)
+                           (syntmp-chi-top-sequence-149
+                             syntmp-body-768
+                             syntmp-r-769
+                             syntmp-w-770
+                             syntmp-s-771
+                             syntmp-m-740
+                             syntmp-esew-741)))
+                       (if (memv syntmp-t-759 (quote (eval-when-form)))
+                         ((lambda (syntmp-tmp-772)
+                            ((lambda (syntmp-tmp-773)
+                               (if syntmp-tmp-773
+                                 (apply (lambda (syntmp-_-774
+                                                 syntmp-x-775
+                                                 syntmp-e1-776
+                                                 syntmp-e2-777)
+                                          (let ((syntmp-when-list-778
+                                                  (syntmp-chi-when-list-151
+                                                    syntmp-e-756
+                                                    syntmp-x-775
+                                                    syntmp-w-757))
+                                                (syntmp-body-779
+                                                  (cons syntmp-e1-776
+                                                        syntmp-e2-777)))
+                                            (cond ((eq? syntmp-m-740 (quote e))
+                                                   (if (memq 'eval
+                                                             syntmp-when-list-778)
+                                                     (syntmp-chi-top-sequence-149
+                                                       syntmp-body-779
+                                                       syntmp-r-738
+                                                       syntmp-w-757
+                                                       syntmp-s-758
+                                                       'e
+                                                       '(eval))
+                                                     (syntmp-chi-void-162)))
+                                                  ((memq 'load
+                                                         syntmp-when-list-778)
+                                                   (if (or (memq 'compile
+                                                                 syntmp-when-list-778)
+                                                           (and (eq? syntmp-m-740
+                                                                     'c&e)
+                                                                (memq 'eval
+                                                                      syntmp-when-list-778)))
+                                                     (syntmp-chi-top-sequence-149
+                                                       syntmp-body-779
+                                                       syntmp-r-738
+                                                       syntmp-w-757
+                                                       syntmp-s-758
+                                                       'c&e
+                                                       '(compile load))
+                                                     (if (memq syntmp-m-740
+                                                               '(c c&e))
+                                                       (syntmp-chi-top-sequence-149
+                                                         syntmp-body-779
+                                                         syntmp-r-738
+                                                         syntmp-w-757
+                                                         syntmp-s-758
+                                                         'c
+                                                         '(load))
+                                                       (syntmp-chi-void-162))))
+                                                  ((or (memq 'compile
+                                                             syntmp-when-list-778)
+                                                       (and (eq? syntmp-m-740
+                                                                 'c&e)
+                                                            (memq 'eval
+                                                                  syntmp-when-list-778)))
+                                                   (syntmp-top-level-eval-hook-93
+                                                     (syntmp-chi-top-sequence-149
+                                                       syntmp-body-779
+                                                       syntmp-r-738
+                                                       syntmp-w-757
+                                                       syntmp-s-758
+                                                       'e
+                                                       '(eval)))
+                                                   (syntmp-chi-void-162))
+                                                  (else
+                                                   (syntmp-chi-void-162)))))
+                                        syntmp-tmp-773)
+                                 (syntax-error syntmp-tmp-772)))
+                             (syntax-dispatch
+                               syntmp-tmp-772
+                               '(any each-any any . each-any))))
+                          syntmp-e-756)
+                         (if (memv syntmp-t-759 (quote (define-syntax-form)))
+                           (let ((syntmp-n-782
+                                   (syntmp-id-var-name-140
+                                     syntmp-value-755
+                                     syntmp-w-757))
+                                 (syntmp-r-783
+                                   (syntmp-macros-only-env-114 syntmp-r-738)))
+                             (let ((syntmp-t-784 syntmp-m-740))
+                               (if (memv syntmp-t-784 (quote (c)))
+                                 (if (memq (quote compile) syntmp-esew-741)
+                                   (let ((syntmp-e-785
+                                           (syntmp-chi-install-global-150
+                                             syntmp-n-782
+                                             (syntmp-chi-154
+                                               syntmp-e-756
+                                               syntmp-r-783
+                                               syntmp-w-757))))
+                                     (begin
+                                       (syntmp-top-level-eval-hook-93
+                                         syntmp-e-785)
+                                       (if (memq (quote load) syntmp-esew-741)
+                                         syntmp-e-785
+                                         (syntmp-chi-void-162))))
+                                   (if (memq (quote load) syntmp-esew-741)
+                                     (syntmp-chi-install-global-150
+                                       syntmp-n-782
+                                       (syntmp-chi-154
+                                         syntmp-e-756
+                                         syntmp-r-783
+                                         syntmp-w-757))
+                                     (syntmp-chi-void-162)))
+                                 (if (memv syntmp-t-784 (quote (c&e)))
+                                   (let ((syntmp-e-786
+                                           (syntmp-chi-install-global-150
+                                             syntmp-n-782
+                                             (syntmp-chi-154
+                                               syntmp-e-756
+                                               syntmp-r-783
+                                               syntmp-w-757))))
+                                     (begin
+                                       (syntmp-top-level-eval-hook-93
+                                         syntmp-e-786)
+                                       syntmp-e-786))
+                                   (begin
+                                     (if (memq (quote eval) syntmp-esew-741)
+                                       (syntmp-top-level-eval-hook-93
+                                         (syntmp-chi-install-global-150
+                                           syntmp-n-782
+                                           (syntmp-chi-154
+                                             syntmp-e-756
+                                             syntmp-r-783
+                                             syntmp-w-757))))
+                                     (syntmp-chi-void-162))))))
+                           (if (memv syntmp-t-759 (quote (define-form)))
+                             (let ((syntmp-n-787
+                                     (syntmp-id-var-name-140
+                                       syntmp-value-755
+                                       syntmp-w-757)))
+                               (let ((syntmp-type-788
+                                       (syntmp-binding-type-110
+                                         (syntmp-lookup-115
+                                           syntmp-n-787
+                                           syntmp-r-738))))
+                                 (let ((syntmp-t-789 syntmp-type-788))
+                                   (if (memv syntmp-t-789 (quote (global)))
+                                     (let ((syntmp-x-790
+                                             (list 'define
+                                                   syntmp-n-787
+                                                   (syntmp-chi-154
+                                                     syntmp-e-756
+                                                     syntmp-r-738
+                                                     syntmp-w-757))))
+                                       (begin
+                                         (if (eq? syntmp-m-740 (quote c&e))
+                                           (syntmp-top-level-eval-hook-93
+                                             syntmp-x-790))
+                                         syntmp-x-790))
+                                     (if (memv syntmp-t-789
+                                               '(displaced-lexical))
+                                       (syntax-error
+                                         (syntmp-wrap-146
+                                           syntmp-value-755
+                                           syntmp-w-757)
+                                         "identifier out of context")
+                                       (if (eq? syntmp-type-788
+                                                'external-macro)
+                                         (let ((syntmp-x-791
+                                                 (list 'define
+                                                       syntmp-n-787
+                                                       (syntmp-chi-154
+                                                         syntmp-e-756
+                                                         syntmp-r-738
+                                                         syntmp-w-757))))
+                                           (begin
+                                             (if (eq? syntmp-m-740 (quote c&e))
+                                               (syntmp-top-level-eval-hook-93
+                                                 syntmp-x-791))
+                                             syntmp-x-791))
+                                         (syntax-error
+                                           (syntmp-wrap-146
+                                             syntmp-value-755
+                                             syntmp-w-757)
+                                           "cannot define keyword at top level")))))))
+                             (let ((syntmp-x-792
+                                     (syntmp-chi-expr-155
+                                       syntmp-type-754
+                                       syntmp-value-755
+                                       syntmp-e-756
+                                       syntmp-r-738
+                                       syntmp-w-757
+                                       syntmp-s-758)))
+                               (begin
+                                 (if (eq? syntmp-m-740 (quote c&e))
+                                   (syntmp-top-level-eval-hook-93
+                                     syntmp-x-792))
+                                 syntmp-x-792))))))))))))
+         (syntmp-syntax-type-152
+           (lambda (syntmp-e-793
+                    syntmp-r-794
+                    syntmp-w-795
+                    syntmp-s-796
+                    syntmp-rib-797)
+             (cond ((symbol? syntmp-e-793)
+                    (let ((syntmp-n-798
+                            (syntmp-id-var-name-140
+                              syntmp-e-793
+                              syntmp-w-795)))
+                      (let ((syntmp-b-799
+                              (syntmp-lookup-115 syntmp-n-798 syntmp-r-794)))
+                        (let ((syntmp-type-800
+                                (syntmp-binding-type-110 syntmp-b-799)))
+                          (let ((syntmp-t-801 syntmp-type-800))
+                            (if (memv syntmp-t-801 (quote (lexical)))
+                              (values
+                                syntmp-type-800
+                                (syntmp-binding-value-111 syntmp-b-799)
+                                syntmp-e-793
+                                syntmp-w-795
+                                syntmp-s-796)
+                              (if (memv syntmp-t-801 (quote (global)))
+                                (values
+                                  syntmp-type-800
+                                  syntmp-n-798
+                                  syntmp-e-793
+                                  syntmp-w-795
+                                  syntmp-s-796)
+                                (if (memv syntmp-t-801 (quote (macro)))
+                                  (syntmp-syntax-type-152
+                                    (syntmp-chi-macro-157
+                                      (syntmp-binding-value-111 syntmp-b-799)
+                                      syntmp-e-793
+                                      syntmp-r-794
+                                      syntmp-w-795
+                                      syntmp-rib-797)
+                                    syntmp-r-794
+                                    '(())
+                                    syntmp-s-796
+                                    syntmp-rib-797)
+                                  (values
+                                    syntmp-type-800
+                                    (syntmp-binding-value-111 syntmp-b-799)
+                                    syntmp-e-793
+                                    syntmp-w-795
+                                    syntmp-s-796)))))))))
+                   ((pair? syntmp-e-793)
+                    (let ((syntmp-first-802 (car syntmp-e-793)))
+                      (if (syntmp-id?-118 syntmp-first-802)
+                        (let ((syntmp-n-803
+                                (syntmp-id-var-name-140
+                                  syntmp-first-802
+                                  syntmp-w-795)))
+                          (let ((syntmp-b-804
+                                  (syntmp-lookup-115
+                                    syntmp-n-803
+                                    syntmp-r-794)))
+                            (let ((syntmp-type-805
+                                    (syntmp-binding-type-110 syntmp-b-804)))
+                              (let ((syntmp-t-806 syntmp-type-805))
+                                (if (memv syntmp-t-806 (quote (lexical)))
+                                  (values
+                                    'lexical-call
+                                    (syntmp-binding-value-111 syntmp-b-804)
+                                    syntmp-e-793
+                                    syntmp-w-795
+                                    syntmp-s-796)
+                                  (if (memv syntmp-t-806 (quote (global)))
+                                    (values
+                                      'global-call
+                                      syntmp-n-803
+                                      syntmp-e-793
+                                      syntmp-w-795
+                                      syntmp-s-796)
+                                    (if (memv syntmp-t-806 (quote (macro)))
+                                      (syntmp-syntax-type-152
+                                        (syntmp-chi-macro-157
+                                          (syntmp-binding-value-111
+                                            syntmp-b-804)
+                                          syntmp-e-793
+                                          syntmp-r-794
+                                          syntmp-w-795
+                                          syntmp-rib-797)
+                                        syntmp-r-794
+                                        '(())
+                                        syntmp-s-796
+                                        syntmp-rib-797)
+                                      (if (memv syntmp-t-806
+                                                '(core external-macro))
+                                        (values
+                                          syntmp-type-805
+                                          (syntmp-binding-value-111
+                                            syntmp-b-804)
+                                          syntmp-e-793
+                                          syntmp-w-795
+                                          syntmp-s-796)
+                                        (if (memv syntmp-t-806
+                                                  '(local-syntax))
+                                          (values
+                                            'local-syntax-form
+                                            (syntmp-binding-value-111
+                                              syntmp-b-804)
+                                            syntmp-e-793
+                                            syntmp-w-795
+                                            syntmp-s-796)
+                                          (if (memv syntmp-t-806
+                                                    '(begin))
+                                            (values
+                                              'begin-form
+                                              #f
+                                              syntmp-e-793
+                                              syntmp-w-795
+                                              syntmp-s-796)
+                                            (if (memv syntmp-t-806
+                                                      '(eval-when))
+                                              (values
+                                                'eval-when-form
+                                                #f
+                                                syntmp-e-793
+                                                syntmp-w-795
+                                                syntmp-s-796)
+                                              (if (memv syntmp-t-806
+                                                        '(define))
+                                                ((lambda (syntmp-tmp-807)
+                                                   ((lambda (syntmp-tmp-808)
+                                                      (if (if syntmp-tmp-808
+                                                            (apply (lambda (syntmp-_-809
+                                                                            syntmp-name-810
+                                                                            syntmp-val-811)
+                                                                     (syntmp-id?-118
+                                                                       syntmp-name-810))
+                                                                   syntmp-tmp-808)
+                                                            #f)
+                                                        (apply (lambda (syntmp-_-812
+                                                                        syntmp-name-813
+                                                                        syntmp-val-814)
+                                                                 (values
+                                                                   'define-form
+                                                                   syntmp-name-813
+                                                                   syntmp-val-814
+                                                                   syntmp-w-795
+                                                                   syntmp-s-796))
+                                                               syntmp-tmp-808)
+                                                        ((lambda (syntmp-tmp-815)
+                                                           (if (if syntmp-tmp-815
+                                                                 (apply (lambda (syntmp-_-816
+                                                                                 syntmp-name-817
+                                                                                 syntmp-args-818
+                                                                                 syntmp-e1-819
+                                                                                 syntmp-e2-820)
+                                                                          (and (syntmp-id?-118
+                                                                                 syntmp-name-817)
+                                                                               (syntmp-valid-bound-ids?-143
+                                                                                 (syntmp-lambda-var-list-167
+                                                                                   syntmp-args-818))))
+                                                                        syntmp-tmp-815)
+                                                                 #f)
+                                                             (apply (lambda (syntmp-_-821
+                                                                             syntmp-name-822
+                                                                             syntmp-args-823
+                                                                             syntmp-e1-824
+                                                                             syntmp-e2-825)
+                                                                      (values
+                                                                        'define-form
+                                                                        (syntmp-wrap-146
+                                                                          syntmp-name-822
+                                                                          syntmp-w-795)
+                                                                        (cons '#(syntax-object
+                                                                                 lambda
+                                                                                 ((top)
+                                                                                  #(ribcage
+                                                                                    #(_
+                                                                                      name
+                                                                                      args
+                                                                                      e1
+                                                                                      e2)
+                                                                                    #((top)
+                                                                                      (top)
+                                                                                      (top)
+                                                                                      (top)
+                                                                                      (top))
+                                                                                    #("i"
+                                                                                      "i"
+                                                                                      "i"
+                                                                                      "i"
+                                                                                      "i"))
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    #(t)
+                                                                                    #(("m"
+                                                                                       top))
+                                                                                    #("i"))
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    #(type)
+                                                                                    #((top))
+                                                                                    #("i"))
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    #(b)
+                                                                                    #((top))
+                                                                                    #("i"))
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    #(n)
+                                                                                    #((top))
+                                                                                    #("i"))
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    #(first)
+                                                                                    #((top))
+                                                                                    #("i"))
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    #(e
+                                                                                      r
+                                                                                      w
+                                                                                      s
+                                                                                      rib)
+                                                                                    #((top)
+                                                                                      (top)
+                                                                                      (top)
+                                                                                      (top)
+                                                                                      (top))
+                                                                                    #("i"
+                                                                                      "i"
+                                                                                      "i"
+                                                                                      "i"
+                                                                                      "i"))
+                                                                                  #(ribcage
+                                                                                    (lambda-var-list
+                                                                                      gen-var
+                                                                                      strip
+                                                                                      strip-annotation
+                                                                                      ellipsis?
+                                                                                      chi-void
+                                                                                      eval-local-transformer
+                                                                                      chi-local-syntax
+                                                                                      chi-lambda-clause
+                                                                                      chi-body
+                                                                                      chi-macro
+                                                                                      chi-application
+                                                                                      chi-expr
+                                                                                      chi
+                                                                                      chi-top
+                                                                                      syntax-type
+                                                                                      chi-when-list
+                                                                                      chi-install-global
+                                                                                      chi-top-sequence
+                                                                                      chi-sequence
+                                                                                      source-wrap
+                                                                                      wrap
+                                                                                      bound-id-member?
+                                                                                      distinct-bound-ids?
+                                                                                      valid-bound-ids?
+                                                                                      bound-id=?
+                                                                                      free-id=?
+                                                                                      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
+                                                                                      unannotate
+                                                                                      set-syntax-object-wrap!
+                                                                                      set-syntax-object-expression!
+                                                                                      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
+                                                                                      build-global-definition
+                                                                                      build-global-assignment
+                                                                                      build-global-reference
+                                                                                      build-lexical-assignment
+                                                                                      build-lexical-reference
+                                                                                      build-conditional
+                                                                                      build-application
+                                                                                      get-global-definition-hook
+                                                                                      put-global-definition-hook
+                                                                                      gensym-hook
+                                                                                      error-hook
+                                                                                      local-eval-hook
+                                                                                      top-level-eval-hook
+                                                                                      annotation?
+                                                                                      fx<
+                                                                                      fx=
+                                                                                      fx-
+                                                                                      fx+
+                                                                                      noexpand)
+                                                                                    ((top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top))
+                                                                                    ("i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"))
+                                                                                  #(ribcage
+                                                                                    (define-structure)
+                                                                                    ((top))
+                                                                                    ("i"))))
+                                                                              (syntmp-wrap-146
+                                                                                (cons syntmp-args-823
+                                                                                      (cons syntmp-e1-824
+                                                                                            syntmp-e2-825))
+                                                                                syntmp-w-795))
+                                                                        '(())
+                                                                        syntmp-s-796))
+                                                                    syntmp-tmp-815)
+                                                             ((lambda (syntmp-tmp-827)
+                                                                (if (if syntmp-tmp-827
+                                                                      (apply (lambda (syntmp-_-828
+                                                                                      syntmp-name-829)
+                                                                               (syntmp-id?-118
+                                                                                 syntmp-name-829))
+                                                                             syntmp-tmp-827)
+                                                                      #f)
+                                                                  (apply (lambda (syntmp-_-830
+                                                                                  syntmp-name-831)
+                                                                           (values
+                                                                             'define-form
+                                                                             (syntmp-wrap-146
+                                                                               syntmp-name-831
+                                                                               syntmp-w-795)
+                                                                             '(#(syntax-object
+                                                                                 void
+                                                                                 ((top)
+                                                                                  #(ribcage
+                                                                                    #(_
+                                                                                      name)
+                                                                                    #((top)
+                                                                                      (top))
+                                                                                    #("i"
+                                                                                      "i"))
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    #(t)
+                                                                                    #(("m"
+                                                                                       top))
+                                                                                    #("i"))
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    #(type)
+                                                                                    #((top))
+                                                                                    #("i"))
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    #(b)
+                                                                                    #((top))
+                                                                                    #("i"))
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    #(n)
+                                                                                    #((top))
+                                                                                    #("i"))
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    #(first)
+                                                                                    #((top))
+                                                                                    #("i"))
+                                                                                  #(ribcage
+                                                                                    ()
+                                                                                    ()
+                                                                                    ())
+                                                                                  #(ribcage
+                                                                                    #(e
+                                                                                      r
+                                                                                      w
+                                                                                      s
+                                                                                      rib)
+                                                                                    #((top)
+                                                                                      (top)
+                                                                                      (top)
+                                                                                      (top)
+                                                                                      (top))
+                                                                                    #("i"
+                                                                                      "i"
+                                                                                      "i"
+                                                                                      "i"
+                                                                                      "i"))
+                                                                                  #(ribcage
+                                                                                    (lambda-var-list
+                                                                                      gen-var
+                                                                                      strip
+                                                                                      strip-annotation
+                                                                                      ellipsis?
+                                                                                      chi-void
+                                                                                      eval-local-transformer
+                                                                                      chi-local-syntax
+                                                                                      chi-lambda-clause
+                                                                                      chi-body
+                                                                                      chi-macro
+                                                                                      chi-application
+                                                                                      chi-expr
+                                                                                      chi
+                                                                                      chi-top
+                                                                                      syntax-type
+                                                                                      chi-when-list
+                                                                                      chi-install-global
+                                                                                      chi-top-sequence
+                                                                                      chi-sequence
+                                                                                      source-wrap
+                                                                                      wrap
+                                                                                      bound-id-member?
+                                                                                      distinct-bound-ids?
+                                                                                      valid-bound-ids?
+                                                                                      bound-id=?
+                                                                                      free-id=?
+                                                                                      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
+                                                                                      unannotate
+                                                                                      set-syntax-object-wrap!
+                                                                                      set-syntax-object-expression!
+                                                                                      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
+                                                                                      build-global-definition
+                                                                                      build-global-assignment
+                                                                                      build-global-reference
+                                                                                      build-lexical-assignment
+                                                                                      build-lexical-reference
+                                                                                      build-conditional
+                                                                                      build-application
+                                                                                      get-global-definition-hook
+                                                                                      put-global-definition-hook
+                                                                                      gensym-hook
+                                                                                      error-hook
+                                                                                      local-eval-hook
+                                                                                      top-level-eval-hook
+                                                                                      annotation?
+                                                                                      fx<
+                                                                                      fx=
+                                                                                      fx-
+                                                                                      fx+
+                                                                                      noexpand)
+                                                                                    ((top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top)
+                                                                                     (top))
+                                                                                    ("i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"
+                                                                                     "i"))
+                                                                                  #(ribcage
+                                                                                    (define-structure)
+                                                                                    ((top))
+                                                                                    ("i")))))
+                                                                             '(())
+                                                                             syntmp-s-796))
+                                                                         syntmp-tmp-827)
+                                                                  (syntax-error
+                                                                    syntmp-tmp-807)))
+                                                              (syntax-dispatch
+                                                                syntmp-tmp-807
+                                                                '(any any)))))
+                                                         (syntax-dispatch
+                                                           syntmp-tmp-807
+                                                           '(any (any . any)
+                                                                 any
+                                                                 .
+                                                                 each-any)))))
+                                                    (syntax-dispatch
+                                                      syntmp-tmp-807
+                                                      '(any any any))))
+                                                 syntmp-e-793)
+                                                (if (memv syntmp-t-806
+                                                          '(define-syntax))
+                                                  ((lambda (syntmp-tmp-832)
+                                                     ((lambda (syntmp-tmp-833)
+                                                        (if (if syntmp-tmp-833
+                                                              (apply (lambda (syntmp-_-834
+                                                                              syntmp-name-835
+                                                                              syntmp-val-836)
+                                                                       (syntmp-id?-118
+                                                                         syntmp-name-835))
+                                                                     syntmp-tmp-833)
+                                                              #f)
+                                                          (apply (lambda (syntmp-_-837
+                                                                          syntmp-name-838
+                                                                          syntmp-val-839)
+                                                                   (values
+                                                                     'define-syntax-form
+                                                                     syntmp-name-838
+                                                                     syntmp-val-839
+                                                                     syntmp-w-795
+                                                                     syntmp-s-796))
+                                                                 syntmp-tmp-833)
+                                                          (syntax-error
+                                                            syntmp-tmp-832)))
+                                                      (syntax-dispatch
+                                                        syntmp-tmp-832
+                                                        '(any any any))))
+                                                   syntmp-e-793)
+                                                  (if (memv syntmp-t-806
+                                                            '(ellipsis))
+                                                    (values
+                                                      'ellipsis
+                                                      (syntmp-make-syntax-object-103
+                                                        (syntmp-syntax-object-expression-105
+                                                          value)
+                                                        (syntmp-anti-mark-133
+                                                          (syntmp-syntax-object-wrap-106
+                                                            value))))
+                                                    (values
+                                                      'call
+                                                      #f
+                                                      syntmp-e-793
+                                                      syntmp-w-795
+                                                      syntmp-s-796)))))))))))))))
+                        (values
+                          'call
+                          #f
+                          syntmp-e-793
+                          syntmp-w-795
+                          syntmp-s-796))))
+                   ((syntmp-syntax-object?-104 syntmp-e-793)
+                    (syntmp-syntax-type-152
+                      (syntmp-syntax-object-expression-105
+                        syntmp-e-793)
+                      syntmp-r-794
+                      (syntmp-join-wraps-137
+                        syntmp-w-795
+                        (syntmp-syntax-object-wrap-106 syntmp-e-793))
+                      #f
+                      syntmp-rib-797))
+                   ((syntmp-annotation?-92 syntmp-e-793)
+                    (syntmp-syntax-type-152
+                      (annotation-expression syntmp-e-793)
+                      syntmp-r-794
+                      syntmp-w-795
+                      (annotation-source syntmp-e-793)
+                      syntmp-rib-797))
+                   ((self-evaluating? syntmp-e-793)
+                    (values
+                      'constant
+                      #f
+                      syntmp-e-793
+                      syntmp-w-795
+                      syntmp-s-796))
+                   (else
+                    (values
+                      'other
+                      #f
+                      syntmp-e-793
+                      syntmp-w-795
+                      syntmp-s-796)))))
+         (syntmp-chi-when-list-151
+           (lambda (syntmp-e-840 syntmp-when-list-841 syntmp-w-842)
+             (let syntmp-f-843 ((syntmp-when-list-844 syntmp-when-list-841)
+                                (syntmp-situations-845 (quote ())))
+               (if (null? syntmp-when-list-844)
+                 syntmp-situations-845
+                 (syntmp-f-843
+                   (cdr syntmp-when-list-844)
+                   (cons (let ((syntmp-x-846 (car syntmp-when-list-844)))
+                           (cond ((syntmp-free-id=?-141
+                                    syntmp-x-846
+                                    '#(syntax-object
+                                       compile
+                                       ((top)
+                                        #(ribcage () () ())
+                                        #(ribcage #(x) #((top)) #("i"))
+                                        #(ribcage () () ())
+                                        #(ribcage
+                                          #(f when-list situations)
+                                          #((top) (top) (top))
+                                          #("i" "i" "i"))
+                                        #(ribcage () () ())
+                                        #(ribcage
+                                          #(e when-list w)
+                                          #((top) (top) (top))
+                                          #("i" "i" "i"))
+                                        #(ribcage
+                                          (lambda-var-list
+                                            gen-var
+                                            strip
+                                            strip-annotation
+                                            ellipsis?
+                                            chi-void
+                                            eval-local-transformer
+                                            chi-local-syntax
+                                            chi-lambda-clause
+                                            chi-body
+                                            chi-macro
+                                            chi-application
+                                            chi-expr
+                                            chi
+                                            chi-top
+                                            syntax-type
+                                            chi-when-list
+                                            chi-install-global
+                                            chi-top-sequence
+                                            chi-sequence
+                                            source-wrap
+                                            wrap
+                                            bound-id-member?
+                                            distinct-bound-ids?
+                                            valid-bound-ids?
+                                            bound-id=?
+                                            free-id=?
+                                            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
+                                            unannotate
+                                            set-syntax-object-wrap!
+                                            set-syntax-object-expression!
+                                            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
+                                            build-global-definition
+                                            build-global-assignment
+                                            build-global-reference
+                                            build-lexical-assignment
+                                            build-lexical-reference
+                                            build-conditional
+                                            build-application
+                                            get-global-definition-hook
+                                            put-global-definition-hook
+                                            gensym-hook
+                                            error-hook
+                                            local-eval-hook
+                                            top-level-eval-hook
+                                            annotation?
+                                            fx<
+                                            fx=
+                                            fx-
+                                            fx+
+                                            noexpand)
+                                          ((top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top)
+                                           (top))
+                                          ("i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"
+                                           "i"