From f8bc344dfcecbc9e2b38eca25ef0677b755633d2 Mon Sep 17 00:00:00 2001 From: Jan Nieuwenhuizen Date: Mon, 19 Dec 2016 19:41:43 +0100 Subject: [PATCH] Import psyntax from Guile-1.8: R7RS with-ellipsis. * GNUmakefile (psyntax-import): New target. * module/mes/psyntax.ss: Import. * module/mes/psyntax-pp.mes: Import. * NEWS: Mention it. --- GNUmakefile | 5 + NEWS | 1 + module/mes/psyntax-1.mes | 5 - module/mes/psyntax-pp.mes | 19508 ++++++++++++++++++------------------ module/mes/psyntax.ss | 339 +- tests/psyntax.test | 36 + 6 files changed, 9877 insertions(+), 10017 deletions(-) diff --git a/GNUmakefile b/GNUmakefile index 3b96a1f7..7623b603 100644 --- a/GNUmakefile +++ b/GNUmakefile @@ -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 621578b3..2946bd4a 100644 --- 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 diff --git a/module/mes/psyntax-1.mes b/module/mes/psyntax-1.mes index 11cb99a1..cce7f8d3 100644 --- a/module/mes/psyntax-1.mes +++ b/module/mes/psyntax-1.mes @@ -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)))) diff --git a/module/mes/psyntax-pp.mes b/module/mes/psyntax-pp.mes index 88397dde..f155f068 100644 --- a/module/mes/psyntax-pp.mes +++ b/module/mes/psyntax-pp.mes @@ -1,9923 +1,9629 @@ -;;; 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" + "i" + "i" + "i" + "i" + "i" + "i" + "i" + "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"))))) + 'compile) + ((syntmp-free-id=?-141 + syntmp-x-846 + '#(syntax-object + load + ((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" + "i" + "i" + "i" + "i" + "i" + "i" + "i" + "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"))))) + 'load) + ((syntmp-free-id=?-141 + syntmp-x-846 + '#(syntax-object + eval + ((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" + "i" + "i" + "i" + "i" + "i" + "i" + "i" + "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"))))) + 'eval) + (else + (syntax-error + (syntmp-wrap-146 syntmp-x-846 syntmp-w-842) + "invalid eval-when situation")))) + syntmp-situations-845)))))) + (syntmp-chi-install-global-150 + (lambda (syntmp-name-847 syntmp-e-848) + (list 'install-global-transformer + (syntmp-build-data-98 #f syntmp-name-847) + syntmp-e-848))) + (syntmp-chi-top-sequence-149 + (lambda (syntmp-body-849 + syntmp-r-850 + syntmp-w-851 + syntmp-s-852 + syntmp-m-853 + syntmp-esew-854) + (syntmp-build-sequence-99 + syntmp-s-852 + (let syntmp-dobody-855 ((syntmp-body-856 syntmp-body-849) + (syntmp-r-857 syntmp-r-850) + (syntmp-w-858 syntmp-w-851) + (syntmp-m-859 syntmp-m-853) + (syntmp-esew-860 syntmp-esew-854)) + (if (null? syntmp-body-856) + '() + (let ((syntmp-first-861 + (syntmp-chi-top-153 + (car syntmp-body-856) + syntmp-r-857 + syntmp-w-858 + syntmp-m-859 + syntmp-esew-860))) + (cons syntmp-first-861 + (syntmp-dobody-855 + (cdr syntmp-body-856) + syntmp-r-857 + syntmp-w-858 + syntmp-m-859 + syntmp-esew-860)))))))) + (syntmp-chi-sequence-148 + (lambda (syntmp-body-862 + syntmp-r-863 + syntmp-w-864 + syntmp-s-865) + (syntmp-build-sequence-99 + syntmp-s-865 + (let syntmp-dobody-866 ((syntmp-body-867 syntmp-body-862) + (syntmp-r-868 syntmp-r-863) + (syntmp-w-869 syntmp-w-864)) + (if (null? syntmp-body-867) + '() + (let ((syntmp-first-870 + (syntmp-chi-154 + (car syntmp-body-867) + syntmp-r-868 + syntmp-w-869))) + (cons syntmp-first-870 + (syntmp-dobody-866 + (cdr syntmp-body-867) + syntmp-r-868 + syntmp-w-869)))))))) + (syntmp-source-wrap-147 + (lambda (syntmp-x-871 syntmp-w-872 syntmp-s-873) + (syntmp-wrap-146 + (if syntmp-s-873 + (make-annotation syntmp-x-871 syntmp-s-873 #f) + syntmp-x-871) + syntmp-w-872))) + (syntmp-wrap-146 + (lambda (syntmp-x-874 syntmp-w-875) + (cond ((and (null? (syntmp-wrap-marks-121 syntmp-w-875)) + (null? (syntmp-wrap-subst-122 syntmp-w-875))) + syntmp-x-874) + ((syntmp-syntax-object?-104 syntmp-x-874) + (syntmp-make-syntax-object-103 + (syntmp-syntax-object-expression-105 + syntmp-x-874) + (syntmp-join-wraps-137 + syntmp-w-875 + (syntmp-syntax-object-wrap-106 syntmp-x-874)))) + ((null? syntmp-x-874) syntmp-x-874) + (else + (syntmp-make-syntax-object-103 + syntmp-x-874 + syntmp-w-875))))) + (syntmp-bound-id-member?-145 + (lambda (syntmp-x-876 syntmp-list-877) + (and (not (null? syntmp-list-877)) + (or (syntmp-bound-id=?-142 + syntmp-x-876 + (car syntmp-list-877)) + (syntmp-bound-id-member?-145 + syntmp-x-876 + (cdr syntmp-list-877)))))) + (syntmp-distinct-bound-ids?-144 + (lambda (syntmp-ids-878) + (let syntmp-distinct?-879 ((syntmp-ids-880 syntmp-ids-878)) + (or (null? syntmp-ids-880) + (and (not (syntmp-bound-id-member?-145 + (car syntmp-ids-880) + (cdr syntmp-ids-880))) + (syntmp-distinct?-879 (cdr syntmp-ids-880))))))) + (syntmp-valid-bound-ids?-143 + (lambda (syntmp-ids-881) + (and (let syntmp-all-ids?-882 ((syntmp-ids-883 syntmp-ids-881)) + (or (null? syntmp-ids-883) + (and (syntmp-id?-118 (car syntmp-ids-883)) + (syntmp-all-ids?-882 (cdr syntmp-ids-883))))) + (syntmp-distinct-bound-ids?-144 syntmp-ids-881)))) + (syntmp-bound-id=?-142 + (lambda (syntmp-i-884 syntmp-j-885) + (if (and (syntmp-syntax-object?-104 syntmp-i-884) + (syntmp-syntax-object?-104 syntmp-j-885)) + (and (eq? (let ((syntmp-e-886 + (syntmp-syntax-object-expression-105 + syntmp-i-884))) + (if (syntmp-annotation?-92 syntmp-e-886) + (annotation-expression syntmp-e-886) + syntmp-e-886)) + (let ((syntmp-e-887 + (syntmp-syntax-object-expression-105 + syntmp-j-885))) + (if (syntmp-annotation?-92 syntmp-e-887) + (annotation-expression syntmp-e-887) + syntmp-e-887))) + (syntmp-same-marks?-139 + (syntmp-wrap-marks-121 + (syntmp-syntax-object-wrap-106 syntmp-i-884)) + (syntmp-wrap-marks-121 + (syntmp-syntax-object-wrap-106 syntmp-j-885)))) + (eq? (let ((syntmp-e-888 syntmp-i-884)) + (if (syntmp-annotation?-92 syntmp-e-888) + (annotation-expression syntmp-e-888) + syntmp-e-888)) + (let ((syntmp-e-889 syntmp-j-885)) + (if (syntmp-annotation?-92 syntmp-e-889) + (annotation-expression syntmp-e-889) + syntmp-e-889)))))) + (syntmp-free-id=?-141 + (lambda (syntmp-i-890 syntmp-j-891) + (and (eq? (let ((syntmp-x-892 syntmp-i-890)) + (let ((syntmp-e-893 + (if (syntmp-syntax-object?-104 syntmp-x-892) + (syntmp-syntax-object-expression-105 + syntmp-x-892) + syntmp-x-892))) + (if (syntmp-annotation?-92 syntmp-e-893) + (annotation-expression syntmp-e-893) + syntmp-e-893))) + (let ((syntmp-x-894 syntmp-j-891)) + (let ((syntmp-e-895 + (if (syntmp-syntax-object?-104 syntmp-x-894) + (syntmp-syntax-object-expression-105 + syntmp-x-894) + syntmp-x-894))) + (if (syntmp-annotation?-92 syntmp-e-895) + (annotation-expression syntmp-e-895) + syntmp-e-895)))) + (eq? (syntmp-id-var-name-140 + syntmp-i-890 + '(())) + (syntmp-id-var-name-140 + syntmp-j-891 + '(())))))) + (syntmp-id-var-name-140 + (lambda (syntmp-id-896 syntmp-w-897) + (letrec ((syntmp-search-vector-rib-900 + (lambda (syntmp-sym-911 + syntmp-subst-912 + syntmp-marks-913 + syntmp-symnames-914 + syntmp-ribcage-915) + (let ((syntmp-n-916 + (vector-length syntmp-symnames-914))) + (let syntmp-f-917 ((syntmp-i-918 0)) + (cond ((syntmp-fx=-90 syntmp-i-918 syntmp-n-916) + (syntmp-search-898 + syntmp-sym-911 + (cdr syntmp-subst-912) + syntmp-marks-913)) + ((and (eq? (vector-ref + syntmp-symnames-914 + syntmp-i-918) + syntmp-sym-911) + (syntmp-same-marks?-139 + syntmp-marks-913 + (vector-ref + (syntmp-ribcage-marks-128 + syntmp-ribcage-915) + syntmp-i-918))) + (values + (vector-ref + (syntmp-ribcage-labels-129 + syntmp-ribcage-915) + syntmp-i-918) + syntmp-marks-913)) + (else + (syntmp-f-917 + (syntmp-fx+-88 syntmp-i-918 1)))))))) + (syntmp-search-list-rib-899 + (lambda (syntmp-sym-919 + syntmp-subst-920 + syntmp-marks-921 + syntmp-symnames-922 + syntmp-ribcage-923) + (let syntmp-f-924 ((syntmp-symnames-925 + syntmp-symnames-922) + (syntmp-i-926 0)) + (cond ((null? syntmp-symnames-925) + (syntmp-search-898 + syntmp-sym-919 + (cdr syntmp-subst-920) + syntmp-marks-921)) + ((and (eq? (car syntmp-symnames-925) + syntmp-sym-919) + (syntmp-same-marks?-139 + syntmp-marks-921 + (list-ref + (syntmp-ribcage-marks-128 + syntmp-ribcage-923) + syntmp-i-926))) + (values + (list-ref + (syntmp-ribcage-labels-129 + syntmp-ribcage-923) + syntmp-i-926) + syntmp-marks-921)) + (else + (syntmp-f-924 + (cdr syntmp-symnames-925) + (syntmp-fx+-88 syntmp-i-926 1))))))) + (syntmp-search-898 + (lambda (syntmp-sym-927 + syntmp-subst-928 + syntmp-marks-929) + (if (null? syntmp-subst-928) + (values #f syntmp-marks-929) + (let ((syntmp-fst-930 (car syntmp-subst-928))) + (if (eq? syntmp-fst-930 (quote shift)) + (syntmp-search-898 + syntmp-sym-927 + (cdr syntmp-subst-928) + (cdr syntmp-marks-929)) + (let ((syntmp-symnames-931 + (syntmp-ribcage-symnames-127 + syntmp-fst-930))) + (if (vector? syntmp-symnames-931) + (syntmp-search-vector-rib-900 + syntmp-sym-927 + syntmp-subst-928 + syntmp-marks-929 + syntmp-symnames-931 + syntmp-fst-930) + (syntmp-search-list-rib-899 + syntmp-sym-927 + syntmp-subst-928 + syntmp-marks-929 + syntmp-symnames-931 + syntmp-fst-930))))))))) + (cond ((symbol? syntmp-id-896) + (or (call-with-values + (lambda () + (syntmp-search-898 + syntmp-id-896 + (syntmp-wrap-subst-122 syntmp-w-897) + (syntmp-wrap-marks-121 syntmp-w-897))) + (lambda (syntmp-x-933 . syntmp-ignore-932) + syntmp-x-933)) + syntmp-id-896)) + ((syntmp-syntax-object?-104 syntmp-id-896) + (let ((syntmp-id-934 + (let ((syntmp-e-936 + (syntmp-syntax-object-expression-105 + syntmp-id-896))) + (if (syntmp-annotation?-92 syntmp-e-936) + (annotation-expression syntmp-e-936) + syntmp-e-936))) + (syntmp-w1-935 + (syntmp-syntax-object-wrap-106 syntmp-id-896))) + (let ((syntmp-marks-937 + (syntmp-join-marks-138 + (syntmp-wrap-marks-121 syntmp-w-897) + (syntmp-wrap-marks-121 syntmp-w1-935)))) + (call-with-values + (lambda () + (syntmp-search-898 + syntmp-id-934 + (syntmp-wrap-subst-122 syntmp-w-897) + syntmp-marks-937)) + (lambda (syntmp-new-id-938 syntmp-marks-939) + (or syntmp-new-id-938 + (call-with-values + (lambda () + (syntmp-search-898 + syntmp-id-934 + (syntmp-wrap-subst-122 syntmp-w1-935) + syntmp-marks-939)) + (lambda (syntmp-x-941 . syntmp-ignore-940) + syntmp-x-941)) + syntmp-id-934)))))) + ((syntmp-annotation?-92 syntmp-id-896) + (let ((syntmp-id-942 + (let ((syntmp-e-943 syntmp-id-896)) + (if (syntmp-annotation?-92 syntmp-e-943) + (annotation-expression syntmp-e-943) + syntmp-e-943)))) + (or (call-with-values + (lambda () + (syntmp-search-898 + syntmp-id-942 + (syntmp-wrap-subst-122 syntmp-w-897) + (syntmp-wrap-marks-121 syntmp-w-897))) + (lambda (syntmp-x-945 . syntmp-ignore-944) + syntmp-x-945)) + syntmp-id-942))) + (else + (syntmp-error-hook-95 + 'id-var-name + "invalid id" + syntmp-id-896)))))) + (syntmp-same-marks?-139 + (lambda (syntmp-x-946 syntmp-y-947) + (or (eq? syntmp-x-946 syntmp-y-947) + (and (not (null? syntmp-x-946)) + (not (null? syntmp-y-947)) + (eq? (car syntmp-x-946) (car syntmp-y-947)) + (syntmp-same-marks?-139 + (cdr syntmp-x-946) + (cdr syntmp-y-947)))))) + (syntmp-join-marks-138 + (lambda (syntmp-m1-948 syntmp-m2-949) + (syntmp-smart-append-136 + syntmp-m1-948 + syntmp-m2-949))) + (syntmp-join-wraps-137 + (lambda (syntmp-w1-950 syntmp-w2-951) + (let ((syntmp-m1-952 + (syntmp-wrap-marks-121 syntmp-w1-950)) + (syntmp-s1-953 + (syntmp-wrap-subst-122 syntmp-w1-950))) + (if (null? syntmp-m1-952) + (if (null? syntmp-s1-953) + syntmp-w2-951 + (syntmp-make-wrap-120 + (syntmp-wrap-marks-121 syntmp-w2-951) + (syntmp-smart-append-136 + syntmp-s1-953 + (syntmp-wrap-subst-122 syntmp-w2-951)))) + (syntmp-make-wrap-120 + (syntmp-smart-append-136 + syntmp-m1-952 + (syntmp-wrap-marks-121 syntmp-w2-951)) + (syntmp-smart-append-136 + syntmp-s1-953 + (syntmp-wrap-subst-122 syntmp-w2-951))))))) + (syntmp-smart-append-136 + (lambda (syntmp-m1-954 syntmp-m2-955) + (if (null? syntmp-m2-955) + syntmp-m1-954 + (append syntmp-m1-954 syntmp-m2-955)))) + (syntmp-make-binding-wrap-135 + (lambda (syntmp-ids-956 syntmp-labels-957 syntmp-w-958) + (if (null? syntmp-ids-956) + syntmp-w-958 + (syntmp-make-wrap-120 + (syntmp-wrap-marks-121 syntmp-w-958) + (cons (let ((syntmp-labelvec-959 + (list->vector syntmp-labels-957))) + (let ((syntmp-n-960 + (vector-length syntmp-labelvec-959))) + (let ((syntmp-symnamevec-961 + (make-vector syntmp-n-960)) + (syntmp-marksvec-962 + (make-vector syntmp-n-960))) + (begin + (let syntmp-f-963 ((syntmp-ids-964 + syntmp-ids-956) + (syntmp-i-965 0)) + (if (not (null? syntmp-ids-964)) + (call-with-values + (lambda () + (syntmp-id-sym-name&marks-119 + (car syntmp-ids-964) + syntmp-w-958)) + (lambda (syntmp-symname-966 + syntmp-marks-967) + (begin + (vector-set! + syntmp-symnamevec-961 + syntmp-i-965 + syntmp-symname-966) + (vector-set! + syntmp-marksvec-962 + syntmp-i-965 + syntmp-marks-967) + (syntmp-f-963 + (cdr syntmp-ids-964) + (syntmp-fx+-88 syntmp-i-965 1))))))) + (syntmp-make-ribcage-125 + syntmp-symnamevec-961 + syntmp-marksvec-962 + syntmp-labelvec-959))))) + (syntmp-wrap-subst-122 syntmp-w-958)))))) + (syntmp-extend-ribcage!-134 + (lambda (syntmp-ribcage-968 + syntmp-id-969 + syntmp-label-970) + (begin + (syntmp-set-ribcage-symnames!-130 + syntmp-ribcage-968 + (cons (let ((syntmp-e-971 + (syntmp-syntax-object-expression-105 + syntmp-id-969))) + (if (syntmp-annotation?-92 syntmp-e-971) + (annotation-expression syntmp-e-971) + syntmp-e-971)) + (syntmp-ribcage-symnames-127 syntmp-ribcage-968))) + (syntmp-set-ribcage-marks!-131 + syntmp-ribcage-968 + (cons (syntmp-wrap-marks-121 + (syntmp-syntax-object-wrap-106 syntmp-id-969)) + (syntmp-ribcage-marks-128 syntmp-ribcage-968))) + (syntmp-set-ribcage-labels!-132 + syntmp-ribcage-968 + (cons syntmp-label-970 + (syntmp-ribcage-labels-129 syntmp-ribcage-968)))))) + (syntmp-anti-mark-133 + (lambda (syntmp-w-972) + (syntmp-make-wrap-120 + (cons #f (syntmp-wrap-marks-121 syntmp-w-972)) + (cons 'shift + (syntmp-wrap-subst-122 syntmp-w-972))))) + (syntmp-set-ribcage-labels!-132 + (lambda (syntmp-x-973 syntmp-update-974) + (vector-set! syntmp-x-973 3 syntmp-update-974))) + (syntmp-set-ribcage-marks!-131 + (lambda (syntmp-x-975 syntmp-update-976) + (vector-set! syntmp-x-975 2 syntmp-update-976))) + (syntmp-set-ribcage-symnames!-130 + (lambda (syntmp-x-977 syntmp-update-978) + (vector-set! syntmp-x-977 1 syntmp-update-978))) + (syntmp-ribcage-labels-129 + (lambda (syntmp-x-979) + (vector-ref syntmp-x-979 3))) + (syntmp-ribcage-marks-128 + (lambda (syntmp-x-980) + (vector-ref syntmp-x-980 2))) + (syntmp-ribcage-symnames-127 + (lambda (syntmp-x-981) + (vector-ref syntmp-x-981 1))) + (syntmp-ribcage?-126 + (lambda (syntmp-x-982) + (and (vector? syntmp-x-982) + (= (vector-length syntmp-x-982) 4) + (eq? (vector-ref syntmp-x-982 0) (quote ribcage))))) + (syntmp-make-ribcage-125 + (lambda (syntmp-symnames-983 + syntmp-marks-984 + syntmp-labels-985) + (vector + 'ribcage + syntmp-symnames-983 + syntmp-marks-984 + syntmp-labels-985))) + (syntmp-gen-labels-124 + (lambda (syntmp-ls-986) + (if (null? syntmp-ls-986) + '() + (cons (syntmp-gen-label-123) + (syntmp-gen-labels-124 (cdr syntmp-ls-986)))))) + (syntmp-gen-label-123 (lambda () (string #\i))) + (syntmp-wrap-subst-122 cdr) + (syntmp-wrap-marks-121 car) + (syntmp-make-wrap-120 cons) + (syntmp-id-sym-name&marks-119 + (lambda (syntmp-x-987 syntmp-w-988) + (if (syntmp-syntax-object?-104 syntmp-x-987) + (values + (let ((syntmp-e-989 + (syntmp-syntax-object-expression-105 + syntmp-x-987))) + (if (syntmp-annotation?-92 syntmp-e-989) + (annotation-expression syntmp-e-989) + syntmp-e-989)) + (syntmp-join-marks-138 + (syntmp-wrap-marks-121 syntmp-w-988) + (syntmp-wrap-marks-121 + (syntmp-syntax-object-wrap-106 syntmp-x-987)))) + (values + (let ((syntmp-e-990 syntmp-x-987)) + (if (syntmp-annotation?-92 syntmp-e-990) + (annotation-expression syntmp-e-990) + syntmp-e-990)) + (syntmp-wrap-marks-121 syntmp-w-988))))) + (syntmp-id?-118 + (lambda (syntmp-x-991) + (cond ((symbol? syntmp-x-991) #t) + ((syntmp-syntax-object?-104 syntmp-x-991) + (symbol? + (let ((syntmp-e-992 + (syntmp-syntax-object-expression-105 + syntmp-x-991))) + (if (syntmp-annotation?-92 syntmp-e-992) + (annotation-expression syntmp-e-992) + syntmp-e-992)))) + ((syntmp-annotation?-92 syntmp-x-991) + (symbol? (annotation-expression syntmp-x-991))) + (else #f)))) + (syntmp-nonsymbol-id?-117 + (lambda (syntmp-x-993) + (and (syntmp-syntax-object?-104 syntmp-x-993) + (symbol? + (let ((syntmp-e-994 + (syntmp-syntax-object-expression-105 + syntmp-x-993))) + (if (syntmp-annotation?-92 syntmp-e-994) + (annotation-expression syntmp-e-994) + syntmp-e-994)))))) + (syntmp-global-extend-116 + (lambda (syntmp-type-995 syntmp-sym-996 syntmp-val-997) + (syntmp-put-global-definition-hook-96 + syntmp-sym-996 + (cons syntmp-type-995 syntmp-val-997)))) + (syntmp-lookup-115 + (lambda (syntmp-x-998 syntmp-r-999) + (cond ((assq syntmp-x-998 syntmp-r-999) => cdr) + ((symbol? syntmp-x-998) + (or (syntmp-get-global-definition-hook-97 + syntmp-x-998) + '(global))) + (else (quote (displaced-lexical)))))) + (syntmp-macros-only-env-114 + (lambda (syntmp-r-1000) + (if (null? syntmp-r-1000) + '() + (let ((syntmp-a-1001 (car syntmp-r-1000))) + (if (memq (cadr syntmp-a-1001) + '(macro ellipsis)) + (cons syntmp-a-1001 + (syntmp-macros-only-env-114 (cdr syntmp-r-1000))) + (syntmp-macros-only-env-114 (cdr syntmp-r-1000))))))) + (syntmp-extend-var-env-113 + (lambda (syntmp-labels-1002 + syntmp-vars-1003 + syntmp-r-1004) + (if (null? syntmp-labels-1002) + syntmp-r-1004 + (syntmp-extend-var-env-113 + (cdr syntmp-labels-1002) + (cdr syntmp-vars-1003) + (cons (cons (car syntmp-labels-1002) + (cons (quote lexical) (car syntmp-vars-1003))) + syntmp-r-1004))))) + (syntmp-extend-env-112 + (lambda (syntmp-labels-1005 + syntmp-bindings-1006 + syntmp-r-1007) + (if (null? syntmp-labels-1005) + syntmp-r-1007 + (syntmp-extend-env-112 + (cdr syntmp-labels-1005) + (cdr syntmp-bindings-1006) + (cons (cons (car syntmp-labels-1005) + (car syntmp-bindings-1006)) + syntmp-r-1007))))) + (syntmp-binding-value-111 cdr) + (syntmp-binding-type-110 car) + (syntmp-source-annotation-109 + (lambda (syntmp-x-1008) + (cond ((syntmp-annotation?-92 syntmp-x-1008) + (annotation-source syntmp-x-1008)) + ((syntmp-syntax-object?-104 syntmp-x-1008) + (syntmp-source-annotation-109 + (syntmp-syntax-object-expression-105 + syntmp-x-1008))) + (else #f)))) + (syntmp-set-syntax-object-wrap!-108 + (lambda (syntmp-x-1009 syntmp-update-1010) + (vector-set! syntmp-x-1009 2 syntmp-update-1010))) + (syntmp-set-syntax-object-expression!-107 + (lambda (syntmp-x-1011 syntmp-update-1012) + (vector-set! syntmp-x-1011 1 syntmp-update-1012))) + (syntmp-syntax-object-wrap-106 + (lambda (syntmp-x-1013) + (vector-ref syntmp-x-1013 2))) + (syntmp-syntax-object-expression-105 + (lambda (syntmp-x-1014) + (vector-ref syntmp-x-1014 1))) + (syntmp-syntax-object?-104 + (lambda (syntmp-x-1015) + (and (vector? syntmp-x-1015) + (= (vector-length syntmp-x-1015) 3) + (eq? (vector-ref syntmp-x-1015 0) + 'syntax-object)))) + (syntmp-make-syntax-object-103 + (lambda (syntmp-expression-1016 syntmp-wrap-1017) + (vector + 'syntax-object + syntmp-expression-1016 + syntmp-wrap-1017))) + (syntmp-build-letrec-102 + (lambda (syntmp-src-1018 + syntmp-vars-1019 + syntmp-val-exps-1020 + syntmp-body-exp-1021) + (if (null? syntmp-vars-1019) + syntmp-body-exp-1021 + (list 'letrec + (map list syntmp-vars-1019 syntmp-val-exps-1020) + syntmp-body-exp-1021)))) + (syntmp-build-named-let-101 + (lambda (syntmp-src-1022 + syntmp-vars-1023 + syntmp-val-exps-1024 + syntmp-body-exp-1025) + (if (null? syntmp-vars-1023) + syntmp-body-exp-1025 + (list 'let + (car syntmp-vars-1023) + (map list + (cdr syntmp-vars-1023) + syntmp-val-exps-1024) + syntmp-body-exp-1025)))) + (syntmp-build-let-100 + (lambda (syntmp-src-1026 + syntmp-vars-1027 + syntmp-val-exps-1028 + syntmp-body-exp-1029) + (if (null? syntmp-vars-1027) + syntmp-body-exp-1029 + (list 'let + (map list syntmp-vars-1027 syntmp-val-exps-1028) + syntmp-body-exp-1029)))) + (syntmp-build-sequence-99 + (lambda (syntmp-src-1030 syntmp-exps-1031) + (if (null? (cdr syntmp-exps-1031)) + (car syntmp-exps-1031) + (cons (quote begin) syntmp-exps-1031)))) + (syntmp-build-data-98 + (lambda (syntmp-src-1032 syntmp-exp-1033) + (if (and (self-evaluating? syntmp-exp-1033) + (not (vector? syntmp-exp-1033))) + syntmp-exp-1033 + (list (quote quote) syntmp-exp-1033)))) + (syntmp-get-global-definition-hook-97 + (lambda (syntmp-symbol-1034) + (getprop + syntmp-symbol-1034 + '*sc-expander*))) + (syntmp-put-global-definition-hook-96 + (lambda (syntmp-symbol-1035 syntmp-binding-1036) + (putprop + syntmp-symbol-1035 + '*sc-expander* + syntmp-binding-1036))) + (syntmp-error-hook-95 + (lambda (syntmp-who-1037 + syntmp-why-1038 + syntmp-what-1039) + (error syntmp-who-1037 + "~a ~s" + syntmp-why-1038 + syntmp-what-1039))) + (syntmp-local-eval-hook-94 + (lambda (syntmp-x-1040) + (eval (list syntmp-noexpand-87 syntmp-x-1040) + (interaction-environment)))) + (syntmp-top-level-eval-hook-93 + (lambda (syntmp-x-1041) + (eval (list syntmp-noexpand-87 syntmp-x-1041) + (interaction-environment)))) + (syntmp-annotation?-92 + (lambda (syntmp-x-1042) #f)) + (syntmp-fx<-91 <) + (syntmp-fx=-90 =) + (syntmp-fx--89 -) + (syntmp-fx+-88 +) + (syntmp-noexpand-87 "noexpand")) + (begin + (syntmp-global-extend-116 + 'local-syntax + 'letrec-syntax + #t) + (syntmp-global-extend-116 + 'local-syntax + 'let-syntax + #f) + (syntmp-global-extend-116 + 'core + 'fluid-let-syntax + (lambda (syntmp-e-1043 + syntmp-r-1044 + syntmp-w-1045 + syntmp-s-1046) + ((lambda (syntmp-tmp-1047) + ((lambda (syntmp-tmp-1048) + (if (if syntmp-tmp-1048 + (apply (lambda (syntmp-_-1049 + syntmp-var-1050 + syntmp-val-1051 + syntmp-e1-1052 + syntmp-e2-1053) + (syntmp-valid-bound-ids?-143 syntmp-var-1050)) + syntmp-tmp-1048) + #f) + (apply (lambda (syntmp-_-1055 + syntmp-var-1056 + syntmp-val-1057 + syntmp-e1-1058 + syntmp-e2-1059) + (let ((syntmp-names-1060 + (map (lambda (syntmp-x-1061) + (syntmp-id-var-name-140 + syntmp-x-1061 + syntmp-w-1045)) + syntmp-var-1056))) + (begin + (for-each + (lambda (syntmp-id-1063 syntmp-n-1064) + (let ((syntmp-t-1065 + (syntmp-binding-type-110 + (syntmp-lookup-115 + syntmp-n-1064 + syntmp-r-1044)))) + (if (memv syntmp-t-1065 + '(displaced-lexical)) + (syntax-error + (syntmp-source-wrap-147 + syntmp-id-1063 + syntmp-w-1045 + syntmp-s-1046) + "identifier out of context")))) + syntmp-var-1056 + syntmp-names-1060) + (syntmp-chi-body-158 + (cons syntmp-e1-1058 syntmp-e2-1059) + (syntmp-source-wrap-147 + syntmp-e-1043 + syntmp-w-1045 + syntmp-s-1046) + (syntmp-extend-env-112 + syntmp-names-1060 + (let ((syntmp-trans-r-1068 + (syntmp-macros-only-env-114 + syntmp-r-1044))) + (map (lambda (syntmp-x-1069) + (cons 'macro + (syntmp-eval-local-transformer-161 + (syntmp-chi-154 + syntmp-x-1069 + syntmp-trans-r-1068 + syntmp-w-1045)))) + syntmp-val-1057)) + syntmp-r-1044) + syntmp-w-1045)))) + syntmp-tmp-1048) + ((lambda (syntmp-_-1071) + (syntax-error + (syntmp-source-wrap-147 + syntmp-e-1043 + syntmp-w-1045 + syntmp-s-1046))) + syntmp-tmp-1047))) + (syntax-dispatch + syntmp-tmp-1047 + '(any #(each (any any)) any . each-any)))) + syntmp-e-1043))) + (syntmp-global-extend-116 + 'core + 'quote + (lambda (syntmp-e-1072 + syntmp-r-1073 + syntmp-w-1074 + syntmp-s-1075) + ((lambda (syntmp-tmp-1076) + ((lambda (syntmp-tmp-1077) + (if syntmp-tmp-1077 + (apply (lambda (syntmp-_-1078 syntmp-e-1079) + (syntmp-build-data-98 + syntmp-s-1075 + (syntmp-strip-165 syntmp-e-1079 syntmp-w-1074))) + syntmp-tmp-1077) + ((lambda (syntmp-_-1080) + (syntax-error + (syntmp-source-wrap-147 + syntmp-e-1072 + syntmp-w-1074 + syntmp-s-1075))) + syntmp-tmp-1076))) + (syntax-dispatch + syntmp-tmp-1076 + '(any any)))) + syntmp-e-1072))) + (syntmp-global-extend-116 + 'core + 'syntax + (letrec ((syntmp-regen-1088 + (lambda (syntmp-x-1089) + (let ((syntmp-t-1090 (car syntmp-x-1089))) + (if (memv syntmp-t-1090 (quote (ref))) + (cadr syntmp-x-1089) + (if (memv syntmp-t-1090 (quote (primitive))) + (cadr syntmp-x-1089) + (if (memv syntmp-t-1090 (quote (quote))) + (syntmp-build-data-98 #f (cadr syntmp-x-1089)) + (if (memv syntmp-t-1090 (quote (lambda))) + (list 'lambda + (cadr syntmp-x-1089) + (syntmp-regen-1088 (caddr syntmp-x-1089))) + (if (memv syntmp-t-1090 (quote (map))) + (let ((syntmp-ls-1091 + (map syntmp-regen-1088 + (cdr syntmp-x-1089)))) + (cons (if (syntmp-fx=-90 + (length syntmp-ls-1091) + 2) + 'map + 'map) + syntmp-ls-1091)) + (cons (car syntmp-x-1089) + (map syntmp-regen-1088 + (cdr syntmp-x-1089))))))))))) + (syntmp-gen-vector-1087 + (lambda (syntmp-x-1092) + (cond ((eq? (car syntmp-x-1092) (quote list)) + (cons (quote vector) (cdr syntmp-x-1092))) + ((eq? (car syntmp-x-1092) (quote quote)) + (list 'quote + (list->vector (cadr syntmp-x-1092)))) + (else (list (quote list->vector) syntmp-x-1092))))) + (syntmp-gen-append-1086 + (lambda (syntmp-x-1093 syntmp-y-1094) + (if (equal? syntmp-y-1094 (quote (quote ()))) + syntmp-x-1093 + (list (quote append) syntmp-x-1093 syntmp-y-1094)))) + (syntmp-gen-cons-1085 + (lambda (syntmp-x-1095 syntmp-y-1096) + (let ((syntmp-t-1097 (car syntmp-y-1096))) + (if (memv syntmp-t-1097 (quote (quote))) + (if (eq? (car syntmp-x-1095) (quote quote)) + (list 'quote + (cons (cadr syntmp-x-1095) + (cadr syntmp-y-1096))) + (if (eq? (cadr syntmp-y-1096) (quote ())) + (list (quote list) syntmp-x-1095) + (list (quote cons) syntmp-x-1095 syntmp-y-1096))) + (if (memv syntmp-t-1097 (quote (list))) + (cons 'list + (cons syntmp-x-1095 (cdr syntmp-y-1096))) + (list (quote cons) syntmp-x-1095 syntmp-y-1096)))))) + (syntmp-gen-map-1084 + (lambda (syntmp-e-1098 syntmp-map-env-1099) + (let ((syntmp-formals-1100 + (map cdr syntmp-map-env-1099)) + (syntmp-actuals-1101 + (map (lambda (syntmp-x-1102) + (list (quote ref) (car syntmp-x-1102))) + syntmp-map-env-1099))) + (cond ((eq? (car syntmp-e-1098) (quote ref)) + (car syntmp-actuals-1101)) + ((andmap + (lambda (syntmp-x-1103) + (and (eq? (car syntmp-x-1103) (quote ref)) + (memq (cadr syntmp-x-1103) + syntmp-formals-1100))) + (cdr syntmp-e-1098)) + (cons 'map + (cons (list 'primitive + (car syntmp-e-1098)) + (map (let ((syntmp-r-1104 + (map cons + syntmp-formals-1100 + syntmp-actuals-1101))) + (lambda (syntmp-x-1105) + (cdr (assq (cadr syntmp-x-1105) + syntmp-r-1104)))) + (cdr syntmp-e-1098))))) + (else + (cons 'map + (cons (list 'lambda + syntmp-formals-1100 + syntmp-e-1098) + syntmp-actuals-1101))))))) + (syntmp-gen-mappend-1083 + (lambda (syntmp-e-1106 syntmp-map-env-1107) + (list 'apply + '(primitive append) + (syntmp-gen-map-1084 + syntmp-e-1106 + syntmp-map-env-1107)))) + (syntmp-gen-ref-1082 + (lambda (syntmp-src-1108 + syntmp-var-1109 + syntmp-level-1110 + syntmp-maps-1111) + (if (syntmp-fx=-90 syntmp-level-1110 0) + (values syntmp-var-1109 syntmp-maps-1111) + (if (null? syntmp-maps-1111) + (syntax-error + syntmp-src-1108 + "missing ellipsis in syntax form") + (call-with-values + (lambda () + (syntmp-gen-ref-1082 + syntmp-src-1108 + syntmp-var-1109 + (syntmp-fx--89 syntmp-level-1110 1) + (cdr syntmp-maps-1111))) + (lambda (syntmp-outer-var-1112 syntmp-outer-maps-1113) + (let ((syntmp-b-1114 + (assq syntmp-outer-var-1112 + (car syntmp-maps-1111)))) + (if syntmp-b-1114 + (values (cdr syntmp-b-1114) syntmp-maps-1111) + (let ((syntmp-inner-var-1115 + (syntmp-gen-var-166 (quote tmp)))) + (values + syntmp-inner-var-1115 + (cons (cons (cons syntmp-outer-var-1112 + syntmp-inner-var-1115) + (car syntmp-maps-1111)) + syntmp-outer-maps-1113))))))))))) + (syntmp-gen-syntax-1081 + (lambda (syntmp-src-1116 + syntmp-e-1117 + syntmp-r-1118 + syntmp-maps-1119 + syntmp-ellipsis?-1120) + (if (syntmp-id?-118 syntmp-e-1117) + (let ((syntmp-label-1121 + (syntmp-id-var-name-140 + syntmp-e-1117 + '(())))) + (let ((syntmp-b-1122 + (syntmp-lookup-115 + syntmp-label-1121 + syntmp-r-1118))) + (if (eq? (syntmp-binding-type-110 syntmp-b-1122) + 'syntax) + (call-with-values + (lambda () + (let ((syntmp-var.lev-1123 + (syntmp-binding-value-111 + syntmp-b-1122))) + (syntmp-gen-ref-1082 + syntmp-src-1116 + (car syntmp-var.lev-1123) + (cdr syntmp-var.lev-1123) + syntmp-maps-1119))) + (lambda (syntmp-var-1124 syntmp-maps-1125) + (values + (list (quote ref) syntmp-var-1124) + syntmp-maps-1125))) + (if (syntmp-ellipsis?-1120 + syntmp-e-1117 + syntmp-r-1118) + (syntax-error + syntmp-src-1116 + "misplaced ellipsis in syntax form") + (values + (list (quote quote) syntmp-e-1117) + syntmp-maps-1119))))) + ((lambda (syntmp-tmp-1126) + ((lambda (syntmp-tmp-1127) + (if (if syntmp-tmp-1127 + (apply (lambda (syntmp-dots-1128 + syntmp-e-1129) + (syntmp-ellipsis?-1120 + syntmp-dots-1128 + syntmp-r-1118)) + syntmp-tmp-1127) + #f) + (apply (lambda (syntmp-dots-1130 syntmp-e-1131) + (syntmp-gen-syntax-1081 + syntmp-src-1116 + syntmp-e-1131 + syntmp-r-1118 + syntmp-maps-1119 + (lambda (syntmp-e-1132 syntmp-r-1133) + #f))) + syntmp-tmp-1127) + ((lambda (syntmp-tmp-1134) + (if (if syntmp-tmp-1134 + (apply (lambda (syntmp-x-1135 + syntmp-dots-1136 + syntmp-y-1137) + (syntmp-ellipsis?-1120 + syntmp-dots-1136 + syntmp-r-1118)) + syntmp-tmp-1134) + #f) + (apply (lambda (syntmp-x-1138 + syntmp-dots-1139 + syntmp-y-1140) + (let syntmp-f-1141 ((syntmp-y-1142 + syntmp-y-1140) + (syntmp-k-1143 + (lambda (syntmp-maps-1144) + (call-with-values + (lambda () + (syntmp-gen-syntax-1081 + syntmp-src-1116 + syntmp-x-1138 + syntmp-r-1118 + (cons '() + syntmp-maps-1144) + syntmp-ellipsis?-1120)) + (lambda (syntmp-x-1145 + syntmp-maps-1146) + (if (null? (car syntmp-maps-1146)) + (syntax-error + syntmp-src-1116 + "extra ellipsis in syntax form") + (values + (syntmp-gen-map-1084 + syntmp-x-1145 + (car syntmp-maps-1146)) + (cdr syntmp-maps-1146)))))))) + ((lambda (syntmp-tmp-1147) + ((lambda (syntmp-tmp-1148) + (if (if syntmp-tmp-1148 + (apply (lambda (syntmp-dots-1149 + syntmp-y-1150) + (syntmp-ellipsis?-1120 + syntmp-dots-1149 + syntmp-r-1118)) + syntmp-tmp-1148) + #f) + (apply (lambda (syntmp-dots-1151 + syntmp-y-1152) + (syntmp-f-1141 + syntmp-y-1152 + (lambda (syntmp-maps-1153) + (call-with-values + (lambda () + (syntmp-k-1143 + (cons '() + syntmp-maps-1153))) + (lambda (syntmp-x-1154 + syntmp-maps-1155) + (if (null? (car syntmp-maps-1155)) + (syntax-error + syntmp-src-1116 + "extra ellipsis in syntax form") + (values + (syntmp-gen-mappend-1083 + syntmp-x-1154 + (car syntmp-maps-1155)) + (cdr syntmp-maps-1155)))))))) + syntmp-tmp-1148) + ((lambda (syntmp-_-1156) + (call-with-values + (lambda () + (syntmp-gen-syntax-1081 + syntmp-src-1116 + syntmp-y-1142 + syntmp-r-1118 + syntmp-maps-1119 + syntmp-ellipsis?-1120)) + (lambda (syntmp-y-1157 + syntmp-maps-1158) + (call-with-values + (lambda () + (syntmp-k-1143 + syntmp-maps-1158)) + (lambda (syntmp-x-1159 + syntmp-maps-1160) + (values + (syntmp-gen-append-1086 + syntmp-x-1159 + syntmp-y-1157) + syntmp-maps-1160)))))) + syntmp-tmp-1147))) + (syntax-dispatch + syntmp-tmp-1147 + '(any . any)))) + syntmp-y-1142))) + syntmp-tmp-1134) + ((lambda (syntmp-tmp-1161) + (if syntmp-tmp-1161 + (apply (lambda (syntmp-x-1162 + syntmp-y-1163) + (call-with-values + (lambda () + (syntmp-gen-syntax-1081 + syntmp-src-1116 + syntmp-x-1162 + syntmp-r-1118 + syntmp-maps-1119 + syntmp-ellipsis?-1120)) + (lambda (syntmp-x-1164 + syntmp-maps-1165) + (call-with-values + (lambda () + (syntmp-gen-syntax-1081 + syntmp-src-1116 + syntmp-y-1163 + syntmp-r-1118 + syntmp-maps-1165 + syntmp-ellipsis?-1120)) + (lambda (syntmp-y-1166 + syntmp-maps-1167) + (values + (syntmp-gen-cons-1085 + syntmp-x-1164 + syntmp-y-1166) + syntmp-maps-1167)))))) + syntmp-tmp-1161) + ((lambda (syntmp-tmp-1168) + (if syntmp-tmp-1168 + (apply (lambda (syntmp-e1-1169 + syntmp-e2-1170) + (call-with-values + (lambda () + (syntmp-gen-syntax-1081 + syntmp-src-1116 + (cons syntmp-e1-1169 + syntmp-e2-1170) + syntmp-r-1118 + syntmp-maps-1119 + syntmp-ellipsis?-1120)) + (lambda (syntmp-e-1172 + syntmp-maps-1173) + (values + (syntmp-gen-vector-1087 + syntmp-e-1172) + syntmp-maps-1173)))) + syntmp-tmp-1168) + ((lambda (syntmp-_-1174) + (values + (list 'quote + syntmp-e-1117) + syntmp-maps-1119)) + syntmp-tmp-1126))) + (syntax-dispatch + syntmp-tmp-1126 + '#(vector (any . each-any)))))) + (syntax-dispatch + syntmp-tmp-1126 + '(any . any))))) + (syntax-dispatch + syntmp-tmp-1126 + '(any any . any))))) + (syntax-dispatch + syntmp-tmp-1126 + '(any any)))) + syntmp-e-1117))))) + (lambda (syntmp-e-1175 + syntmp-r-1176 + syntmp-w-1177 + syntmp-s-1178) + (let ((syntmp-e-1179 + (syntmp-source-wrap-147 + syntmp-e-1175 + syntmp-w-1177 + syntmp-s-1178))) + ((lambda (syntmp-tmp-1180) + ((lambda (syntmp-tmp-1181) + (if syntmp-tmp-1181 + (apply (lambda (syntmp-_-1182 syntmp-x-1183) + (call-with-values + (lambda () + (syntmp-gen-syntax-1081 + syntmp-e-1179 + syntmp-x-1183 + syntmp-r-1176 + '() + syntmp-ellipsis?-163)) + (lambda (syntmp-e-1184 syntmp-maps-1185) + (syntmp-regen-1088 syntmp-e-1184)))) + syntmp-tmp-1181) + ((lambda (syntmp-_-1186) + (syntax-error syntmp-e-1179)) + syntmp-tmp-1180))) + (syntax-dispatch + syntmp-tmp-1180 + '(any any)))) + syntmp-e-1179))))) + (syntmp-global-extend-116 + 'core + 'lambda + (lambda (syntmp-e-1187 + syntmp-r-1188 + syntmp-w-1189 + syntmp-s-1190) + ((lambda (syntmp-tmp-1191) + ((lambda (syntmp-tmp-1192) + (if syntmp-tmp-1192 + (apply (lambda (syntmp-_-1193 syntmp-c-1194) + (syntmp-chi-lambda-clause-159 + (syntmp-source-wrap-147 + syntmp-e-1187 + syntmp-w-1189 + syntmp-s-1190) + syntmp-c-1194 + syntmp-r-1188 + syntmp-w-1189 + (lambda (syntmp-vars-1195 syntmp-body-1196) + (list 'lambda + syntmp-vars-1195 + syntmp-body-1196)))) + syntmp-tmp-1192) + (syntax-error syntmp-tmp-1191))) + (syntax-dispatch + syntmp-tmp-1191 + '(any . any)))) + syntmp-e-1187))) + (syntmp-global-extend-116 + 'core + 'with-ellipsis + (lambda (syntmp-e-1197 + syntmp-r-1198 + syntmp-w-1199 + syntmp-s-1200) + (let ((syntmp-tmp-1201 syntmp-e-1197)) + (let ((syntmp-tmp-1202 + (syntax-dispatch + syntmp-tmp-1201 + '(_ any any . each-any)))) + (if (and syntmp-tmp-1202 + (apply (lambda (syntmp-dots-1203 + syntmp-e1-1204 + syntmp-e2-1205) + (syntmp-id?-118 syntmp-dots-1203)) + syntmp-tmp-1202)) + (apply (lambda (syntmp-dots-1206 syntmp-e1-1207 syntmp-e2-1208) + (let ((syntmp-id-1209 + (if (symbol? syntmp-dots-1206) + '$sc-ellipsis + (syntmp-make-syntax-object-103 + '$sc-ellipsis + (syntmp-syntax-object-wrap-106 + syntmp-dots-1206))))) + (let ((syntmp-ids-1210 (list syntmp-id-1209)) + (syntmp-labels-1211 + (list (syntmp-gen-label-123))) + (syntmp-bindings-1212 + (list (cons 'ellipsis + (syntmp-source-wrap-147 + syntmp-dots-1206 + syntmp-w-1199 + syntmp-s-1200))))) + (let ((syntmp-nw-1213 + (syntmp-make-binding-wrap-135 + syntmp-ids-1210 + syntmp-labels-1211 + syntmp-w-1199)) + (syntmp-nr-1214 + (syntmp-extend-env-112 + syntmp-labels-1211 + syntmp-bindings-1212 + syntmp-r-1198))) + (syntmp-chi-body-158 + (cons syntmp-e1-1207 syntmp-e2-1208) + (syntmp-source-wrap-147 + syntmp-e-1197 + syntmp-nw-1213 + syntmp-s-1200) + syntmp-nr-1214 + syntmp-nw-1213))))) + syntmp-tmp-1202) + (syntax-error (quote with-ellipsis) "bad syntax")))))) + (syntmp-global-extend-116 + 'core + 'let + (letrec ((syntmp-chi-let-1215 + (lambda (syntmp-e-1216 + syntmp-r-1217 + syntmp-w-1218 + syntmp-s-1219 + syntmp-constructor-1220 + syntmp-ids-1221 + syntmp-vals-1222 + syntmp-exps-1223) + (if (not (syntmp-valid-bound-ids?-143 syntmp-ids-1221)) + (syntax-error + syntmp-e-1216 + "duplicate bound variable in") + (let ((syntmp-labels-1224 + (syntmp-gen-labels-124 syntmp-ids-1221)) + (syntmp-new-vars-1225 + (map syntmp-gen-var-166 syntmp-ids-1221))) + (let ((syntmp-nw-1226 + (syntmp-make-binding-wrap-135 + syntmp-ids-1221 + syntmp-labels-1224 + syntmp-w-1218)) + (syntmp-nr-1227 + (syntmp-extend-var-env-113 + syntmp-labels-1224 + syntmp-new-vars-1225 + syntmp-r-1217))) + (syntmp-constructor-1220 + syntmp-s-1219 + syntmp-new-vars-1225 + (map (lambda (syntmp-x-1228) + (syntmp-chi-154 + syntmp-x-1228 + syntmp-r-1217 + syntmp-w-1218)) + syntmp-vals-1222) + (syntmp-chi-body-158 + syntmp-exps-1223 + (syntmp-source-wrap-147 + syntmp-e-1216 + syntmp-nw-1226 + syntmp-s-1219) + syntmp-nr-1227 + syntmp-nw-1226)))))))) + (lambda (syntmp-e-1229 + syntmp-r-1230 + syntmp-w-1231 + syntmp-s-1232) + ((lambda (syntmp-tmp-1233) + ((lambda (syntmp-tmp-1234) + (if syntmp-tmp-1234 + (apply (lambda (syntmp-_-1235 + syntmp-id-1236 + syntmp-val-1237 + syntmp-e1-1238 + syntmp-e2-1239) + (syntmp-chi-let-1215 + syntmp-e-1229 + syntmp-r-1230 + syntmp-w-1231 + syntmp-s-1232 + syntmp-build-let-100 + syntmp-id-1236 + syntmp-val-1237 + (cons syntmp-e1-1238 syntmp-e2-1239))) + syntmp-tmp-1234) + ((lambda (syntmp-tmp-1243) + (if (if syntmp-tmp-1243 + (apply (lambda (syntmp-_-1244 + syntmp-f-1245 + syntmp-id-1246 + syntmp-val-1247 + syntmp-e1-1248 + syntmp-e2-1249) + (syntmp-id?-118 syntmp-f-1245)) + syntmp-tmp-1243) + #f) + (apply (lambda (syntmp-_-1250 + syntmp-f-1251 + syntmp-id-1252 + syntmp-val-1253 + syntmp-e1-1254 + syntmp-e2-1255) + (syntmp-chi-let-1215 + syntmp-e-1229 + syntmp-r-1230 + syntmp-w-1231 + syntmp-s-1232 + syntmp-build-named-let-101 + (cons syntmp-f-1251 syntmp-id-1252) + syntmp-val-1253 + (cons syntmp-e1-1254 syntmp-e2-1255))) + syntmp-tmp-1243) + ((lambda (syntmp-_-1259) + (syntax-error + (syntmp-source-wrap-147 + syntmp-e-1229 + syntmp-w-1231 + syntmp-s-1232))) + syntmp-tmp-1233))) + (syntax-dispatch + syntmp-tmp-1233 + '(any any #(each (any any)) any . each-any))))) + (syntax-dispatch + syntmp-tmp-1233 + '(any #(each (any any)) any . each-any)))) + syntmp-e-1229)))) + (syntmp-global-extend-116 + 'core + 'letrec + (lambda (syntmp-e-1260 + syntmp-r-1261 + syntmp-w-1262 + syntmp-s-1263) + ((lambda (syntmp-tmp-1264) + ((lambda (syntmp-tmp-1265) + (if syntmp-tmp-1265 + (apply (lambda (syntmp-_-1266 + syntmp-id-1267 + syntmp-val-1268 + syntmp-e1-1269 + syntmp-e2-1270) + (let ((syntmp-ids-1271 syntmp-id-1267)) + (if (not (syntmp-valid-bound-ids?-143 + syntmp-ids-1271)) + (syntax-error + syntmp-e-1260 + "duplicate bound variable in") + (let ((syntmp-labels-1273 + (syntmp-gen-labels-124 syntmp-ids-1271)) + (syntmp-new-vars-1274 + (map syntmp-gen-var-166 syntmp-ids-1271))) + (let ((syntmp-w-1275 + (syntmp-make-binding-wrap-135 + syntmp-ids-1271 + syntmp-labels-1273 + syntmp-w-1262)) + (syntmp-r-1276 + (syntmp-extend-var-env-113 + syntmp-labels-1273 + syntmp-new-vars-1274 + syntmp-r-1261))) + (syntmp-build-letrec-102 + syntmp-s-1263 + syntmp-new-vars-1274 + (map (lambda (syntmp-x-1277) + (syntmp-chi-154 + syntmp-x-1277 + syntmp-r-1276 + syntmp-w-1275)) + syntmp-val-1268) + (syntmp-chi-body-158 + (cons syntmp-e1-1269 syntmp-e2-1270) + (syntmp-source-wrap-147 + syntmp-e-1260 + syntmp-w-1275 + syntmp-s-1263) + syntmp-r-1276 + syntmp-w-1275))))))) + syntmp-tmp-1265) + ((lambda (syntmp-_-1280) + (syntax-error + (syntmp-source-wrap-147 + syntmp-e-1260 + syntmp-w-1262 + syntmp-s-1263))) + syntmp-tmp-1264))) + (syntax-dispatch + syntmp-tmp-1264 + '(any #(each (any any)) any . each-any)))) + syntmp-e-1260))) + (syntmp-global-extend-116 + 'core + 'set! + (lambda (syntmp-e-1281 + syntmp-r-1282 + syntmp-w-1283 + syntmp-s-1284) + ((lambda (syntmp-tmp-1285) + ((lambda (syntmp-tmp-1286) + (if (if syntmp-tmp-1286 + (apply (lambda (syntmp-_-1287 + syntmp-id-1288 + syntmp-val-1289) + (syntmp-id?-118 syntmp-id-1288)) + syntmp-tmp-1286) + #f) + (apply (lambda (syntmp-_-1290 syntmp-id-1291 syntmp-val-1292) + (let ((syntmp-val-1293 + (syntmp-chi-154 + syntmp-val-1292 + syntmp-r-1282 + syntmp-w-1283)) + (syntmp-n-1294 + (syntmp-id-var-name-140 + syntmp-id-1291 + syntmp-w-1283))) + (let ((syntmp-b-1295 + (syntmp-lookup-115 + syntmp-n-1294 + syntmp-r-1282))) + (let ((syntmp-t-1296 + (syntmp-binding-type-110 syntmp-b-1295))) + (if (memv syntmp-t-1296 (quote (lexical))) + (list 'set! + (syntmp-binding-value-111 syntmp-b-1295) + syntmp-val-1293) + (if (memv syntmp-t-1296 (quote (global))) + (list 'set! + syntmp-n-1294 + syntmp-val-1293) + (if (memv syntmp-t-1296 + '(displaced-lexical)) + (syntax-error + (syntmp-wrap-146 + syntmp-id-1291 + syntmp-w-1283) + "identifier out of context") + (syntax-error + (syntmp-source-wrap-147 + syntmp-e-1281 + syntmp-w-1283 + syntmp-s-1284))))))))) + syntmp-tmp-1286) + ((lambda (syntmp-tmp-1297) + (if syntmp-tmp-1297 + (apply (lambda (syntmp-_-1298 + syntmp-getter-1299 + syntmp-arg-1300 + syntmp-val-1301) + (cons (syntmp-chi-154 + (list '#(syntax-object + setter + ((top) + #(ribcage + #(_ getter arg val) + #((top) (top) (top) (top)) + #("i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage + #(e r w s) + #((top) (top) (top) (top)) + #("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-getter-1299) + syntmp-r-1282 + syntmp-w-1283) + (map (lambda (syntmp-e-1302) + (syntmp-chi-154 + syntmp-e-1302 + syntmp-r-1282 + syntmp-w-1283)) + (append + syntmp-arg-1300 + (list syntmp-val-1301))))) + syntmp-tmp-1297) + ((lambda (syntmp-_-1304) + (syntax-error + (syntmp-source-wrap-147 + syntmp-e-1281 + syntmp-w-1283 + syntmp-s-1284))) + syntmp-tmp-1285))) + (syntax-dispatch + syntmp-tmp-1285 + '(any (any . each-any) any))))) + (syntax-dispatch + syntmp-tmp-1285 + '(any any any)))) + syntmp-e-1281))) + (syntmp-global-extend-116 + 'begin + 'begin + '()) + (syntmp-global-extend-116 + 'define + 'define + '()) + (syntmp-global-extend-116 + 'define-syntax + 'define-syntax + '()) + (syntmp-global-extend-116 + 'eval-when + 'eval-when + '()) + (syntmp-global-extend-116 + 'core + 'syntax-case + (letrec ((syntmp-gen-syntax-case-1308 + (lambda (syntmp-x-1309 + syntmp-keys-1310 + syntmp-clauses-1311 + syntmp-r-1312) + (if (null? syntmp-clauses-1311) + (list (quote syntax-error) syntmp-x-1309) + ((lambda (syntmp-tmp-1313) + ((lambda (syntmp-tmp-1314) + (if syntmp-tmp-1314 + (apply (lambda (syntmp-pat-1315 syntmp-exp-1316) + (if (and (syntmp-id?-118 syntmp-pat-1315) + (andmap + (lambda (syntmp-x-1317) + (not (syntmp-free-id=?-141 + syntmp-pat-1315 + syntmp-x-1317))) + (cons '#(syntax-object + ... + ((top) + #(ribcage + #(pat exp) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage + #(x + keys + clauses + r) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")) + #(ribcage + (gen-syntax-case + gen-clause + build-dispatch-call + convert-pattern) + ((top) + (top) + (top) + (top)) + ("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-keys-1310))) + (let ((syntmp-labels-1318 + (list (syntmp-gen-label-123))) + (syntmp-var-1319 + (syntmp-gen-var-166 + syntmp-pat-1315))) + (list (list 'lambda + (list syntmp-var-1319) + (syntmp-chi-154 + syntmp-exp-1316 + (syntmp-extend-env-112 + syntmp-labels-1318 + (list (cons 'syntax + (cons syntmp-var-1319 + 0))) + syntmp-r-1312) + (syntmp-make-binding-wrap-135 + (list syntmp-pat-1315) + syntmp-labels-1318 + '(())))) + syntmp-x-1309)) + (syntmp-gen-clause-1307 + syntmp-x-1309 + syntmp-keys-1310 + (cdr syntmp-clauses-1311) + syntmp-r-1312 + syntmp-pat-1315 + #t + syntmp-exp-1316))) + syntmp-tmp-1314) + ((lambda (syntmp-tmp-1320) + (if syntmp-tmp-1320 + (apply (lambda (syntmp-pat-1321 + syntmp-fender-1322 + syntmp-exp-1323) + (syntmp-gen-clause-1307 + syntmp-x-1309 + syntmp-keys-1310 + (cdr syntmp-clauses-1311) + syntmp-r-1312 + syntmp-pat-1321 + syntmp-fender-1322 + syntmp-exp-1323)) + syntmp-tmp-1320) + ((lambda (syntmp-_-1324) + (syntax-error + (car syntmp-clauses-1311) + "invalid syntax-case clause")) + syntmp-tmp-1313))) + (syntax-dispatch + syntmp-tmp-1313 + '(any any any))))) + (syntax-dispatch + syntmp-tmp-1313 + '(any any)))) + (car syntmp-clauses-1311))))) + (syntmp-gen-clause-1307 + (lambda (syntmp-x-1325 + syntmp-keys-1326 + syntmp-clauses-1327 + syntmp-r-1328 + syntmp-pat-1329 + syntmp-fender-1330 + syntmp-exp-1331) + (call-with-values + (lambda () + (syntmp-convert-pattern-1305 + syntmp-pat-1329 + syntmp-keys-1326 + (lambda (syntmp-e-1332) + (syntmp-ellipsis?-163 + syntmp-e-1332 + syntmp-r-1328)))) + (lambda (syntmp-p-1333 syntmp-pvars-1334) + (cond ((not (syntmp-distinct-bound-ids?-144 + (map car syntmp-pvars-1334))) + (syntax-error + syntmp-pat-1329 + "duplicate pattern variable in syntax-case pattern")) + ((not (andmap + (lambda (syntmp-x-1335) + (not (syntmp-ellipsis?-163 + (car syntmp-x-1335) + syntmp-r-1328))) + syntmp-pvars-1334)) + (syntax-error + syntmp-pat-1329 + "misplaced ellipsis in syntax-case pattern")) + (else + (let ((syntmp-y-1336 + (syntmp-gen-var-166 (quote tmp)))) + (list (list 'lambda + (list syntmp-y-1336) + (let ((syntmp-y-1337 + syntmp-y-1336)) + (list 'if + ((lambda (syntmp-tmp-1338) + ((lambda (syntmp-tmp-1339) + (if syntmp-tmp-1339 + (apply (lambda () + syntmp-y-1337) + syntmp-tmp-1339) + ((lambda (syntmp-_-1340) + (list 'if + syntmp-y-1337 + (syntmp-build-dispatch-call-1306 + syntmp-pvars-1334 + syntmp-fender-1330 + syntmp-y-1337 + syntmp-r-1328) + (syntmp-build-data-98 + #f + #f))) + syntmp-tmp-1338))) + (syntax-dispatch + syntmp-tmp-1338 + '#(atom #t)))) + syntmp-fender-1330) + (syntmp-build-dispatch-call-1306 + syntmp-pvars-1334 + syntmp-exp-1331 + syntmp-y-1337 + syntmp-r-1328) + (syntmp-gen-syntax-case-1308 + syntmp-x-1325 + syntmp-keys-1326 + syntmp-clauses-1327 + syntmp-r-1328)))) + (if (eq? syntmp-p-1333 (quote any)) + (list (quote list) syntmp-x-1325) + (list 'syntax-dispatch + syntmp-x-1325 + (syntmp-build-data-98 + #f + syntmp-p-1333))))))))))) + (syntmp-build-dispatch-call-1306 + (lambda (syntmp-pvars-1341 + syntmp-exp-1342 + syntmp-y-1343 + syntmp-r-1344) + (let ((syntmp-ids-1345 (map car syntmp-pvars-1341)) + (syntmp-levels-1346 (map cdr syntmp-pvars-1341))) + (let ((syntmp-labels-1347 + (syntmp-gen-labels-124 syntmp-ids-1345)) + (syntmp-new-vars-1348 + (map syntmp-gen-var-166 syntmp-ids-1345))) + (list 'apply + (list 'lambda + syntmp-new-vars-1348 + (syntmp-chi-154 + syntmp-exp-1342 + (syntmp-extend-env-112 + syntmp-labels-1347 + (map (lambda (syntmp-var-1349 + syntmp-level-1350) + (cons 'syntax + (cons syntmp-var-1349 + syntmp-level-1350))) + syntmp-new-vars-1348 + (map cdr syntmp-pvars-1341)) + syntmp-r-1344) + (syntmp-make-binding-wrap-135 + syntmp-ids-1345 + syntmp-labels-1347 + '(())))) + syntmp-y-1343))))) + (syntmp-convert-pattern-1305 + (lambda (syntmp-pattern-1351 + syntmp-keys-1352 + syntmp-ellipsis?-1353) + (let syntmp-cvt-1354 ((syntmp-p-1355 syntmp-pattern-1351) + (syntmp-n-1356 0) + (syntmp-ids-1357 (quote ()))) + (if (syntmp-id?-118 syntmp-p-1355) + (if (syntmp-bound-id-member?-145 + syntmp-p-1355 + syntmp-keys-1352) + (values + (vector (quote free-id) syntmp-p-1355) + syntmp-ids-1357) + (values + 'any + (cons (cons syntmp-p-1355 syntmp-n-1356) + syntmp-ids-1357))) + ((lambda (syntmp-tmp-1358) + ((lambda (syntmp-tmp-1359) + (if (if syntmp-tmp-1359 + (apply (lambda (syntmp-x-1360 + syntmp-dots-1361) + (syntmp-ellipsis?-1353 + syntmp-dots-1361)) + syntmp-tmp-1359) + #f) + (apply (lambda (syntmp-x-1362 syntmp-dots-1363) + (call-with-values + (lambda () + (syntmp-cvt-1354 + syntmp-x-1362 + (syntmp-fx+-88 syntmp-n-1356 1) + syntmp-ids-1357)) + (lambda (syntmp-p-1364 + syntmp-ids-1365) + (values + (if (eq? syntmp-p-1364 + 'any) + 'each-any + (vector + 'each + syntmp-p-1364)) + syntmp-ids-1365)))) + syntmp-tmp-1359) + ((lambda (syntmp-tmp-1366) + (if syntmp-tmp-1366 + (apply (lambda (syntmp-x-1367 + syntmp-y-1368) + (call-with-values + (lambda () + (syntmp-cvt-1354 + syntmp-y-1368 + syntmp-n-1356 + syntmp-ids-1357)) + (lambda (syntmp-y-1369 + syntmp-ids-1370) + (call-with-values + (lambda () + (syntmp-cvt-1354 + syntmp-x-1367 + syntmp-n-1356 + syntmp-ids-1370)) + (lambda (syntmp-x-1371 + syntmp-ids-1372) + (values + (cons syntmp-x-1371 + syntmp-y-1369) + syntmp-ids-1372)))))) + syntmp-tmp-1366) + ((lambda (syntmp-tmp-1373) + (if syntmp-tmp-1373 + (apply (lambda () + (values + '() + syntmp-ids-1357)) + syntmp-tmp-1373) + ((lambda (syntmp-tmp-1374) + (if syntmp-tmp-1374 + (apply (lambda (syntmp-x-1375) + (call-with-values + (lambda () + (syntmp-cvt-1354 + syntmp-x-1375 + syntmp-n-1356 + syntmp-ids-1357)) + (lambda (syntmp-p-1377 + syntmp-ids-1378) + (values + (vector + 'vector + syntmp-p-1377) + syntmp-ids-1378)))) + syntmp-tmp-1374) + ((lambda (syntmp-x-1379) + (values + (vector + 'atom + (syntmp-strip-165 + syntmp-p-1355 + '(()))) + syntmp-ids-1357)) + syntmp-tmp-1358))) + (syntax-dispatch + syntmp-tmp-1358 + '#(vector each-any))))) + (syntax-dispatch + syntmp-tmp-1358 + '())))) + (syntax-dispatch + syntmp-tmp-1358 + '(any . any))))) + (syntax-dispatch + syntmp-tmp-1358 + '(any any)))) + syntmp-p-1355)))))) + (lambda (syntmp-e-1380 + syntmp-r-1381 + syntmp-w-1382 + syntmp-s-1383) + (let ((syntmp-e-1384 + (syntmp-source-wrap-147 + syntmp-e-1380 + syntmp-w-1382 + syntmp-s-1383))) + ((lambda (syntmp-tmp-1385) + ((lambda (syntmp-tmp-1386) + (if syntmp-tmp-1386 + (apply (lambda (syntmp-_-1387 + syntmp-val-1388 + syntmp-key-1389 + syntmp-m-1390) + (if (andmap + (lambda (syntmp-x-1391) + (and (syntmp-id?-118 syntmp-x-1391) + (not (syntmp-ellipsis?-163 + syntmp-x-1391 + syntmp-r-1381)))) + syntmp-key-1389) + (let ((syntmp-x-1393 + (syntmp-gen-var-166 (quote tmp)))) + (list (list 'lambda + (list syntmp-x-1393) + (syntmp-gen-syntax-case-1308 + syntmp-x-1393 + syntmp-key-1389 + syntmp-m-1390 + syntmp-r-1381)) + (syntmp-chi-154 + syntmp-val-1388 + syntmp-r-1381 + '(())))) + (syntax-error + syntmp-e-1384 + "invalid literals list in"))) + syntmp-tmp-1386) + (syntax-error syntmp-tmp-1385))) + (syntax-dispatch + syntmp-tmp-1385 + '(any any each-any . each-any)))) + syntmp-e-1384))))) + (set! sc-expand + (let ((syntmp-m-1396 (quote e)) + (syntmp-esew-1397 (quote (eval)))) + (lambda (syntmp-x-1398) + (if (and (pair? syntmp-x-1398) + (equal? (car syntmp-x-1398) syntmp-noexpand-87)) + (cadr syntmp-x-1398) + (syntmp-chi-top-153 + syntmp-x-1398 + '() + '((top)) + syntmp-m-1396 + syntmp-esew-1397))))) + (set! sc-expand3 + (let ((syntmp-m-1399 (quote e)) + (syntmp-esew-1400 (quote (eval)))) + (lambda (syntmp-x-1402 . syntmp-rest-1401) + (if (and (pair? syntmp-x-1402) + (equal? (car syntmp-x-1402) syntmp-noexpand-87)) + (cadr syntmp-x-1402) + (syntmp-chi-top-153 + syntmp-x-1402 + '() + '((top)) + (if (null? syntmp-rest-1401) + syntmp-m-1399 + (car syntmp-rest-1401)) + (if (or (null? syntmp-rest-1401) + (null? (cdr syntmp-rest-1401))) + syntmp-esew-1400 + (cadr syntmp-rest-1401))))))) + (set! identifier? + (lambda (syntmp-x-1403) + (syntmp-nonsymbol-id?-117 syntmp-x-1403))) + (set! datum->syntax-object + (lambda (syntmp-id-1404 syntmp-datum-1405) + (syntmp-make-syntax-object-103 + syntmp-datum-1405 + (syntmp-syntax-object-wrap-106 syntmp-id-1404)))) + (set! syntax-object->datum + (lambda (syntmp-x-1406) + (syntmp-strip-165 syntmp-x-1406 (quote (()))))) + (set! generate-temporaries + (lambda (syntmp-ls-1407) + (begin + (let ((syntmp-x-1408 syntmp-ls-1407)) + (if (not (list? syntmp-x-1408)) + (syntmp-error-hook-95 + 'generate-temporaries + "invalid argument" + syntmp-x-1408))) + (map (lambda (syntmp-x-1409) + (syntmp-wrap-146 (gensym) (quote ((top))))) + syntmp-ls-1407)))) + (set! free-identifier=? + (lambda (syntmp-x-1410 syntmp-y-1411) + (begin + (let ((syntmp-x-1412 syntmp-x-1410)) + (if (not (syntmp-nonsymbol-id?-117 syntmp-x-1412)) + (syntmp-error-hook-95 + 'free-identifier=? + "invalid argument" + syntmp-x-1412))) + (let ((syntmp-x-1413 syntmp-y-1411)) + (if (not (syntmp-nonsymbol-id?-117 syntmp-x-1413)) + (syntmp-error-hook-95 + 'free-identifier=? + "invalid argument" + syntmp-x-1413))) + (syntmp-free-id=?-141 + syntmp-x-1410 + syntmp-y-1411)))) + (set! bound-identifier=? + (lambda (syntmp-x-1414 syntmp-y-1415) + (begin + (let ((syntmp-x-1416 syntmp-x-1414)) + (if (not (syntmp-nonsymbol-id?-117 syntmp-x-1416)) + (syntmp-error-hook-95 + 'bound-identifier=? + "invalid argument" + syntmp-x-1416))) + (let ((syntmp-x-1417 syntmp-y-1415)) + (if (not (syntmp-nonsymbol-id?-117 syntmp-x-1417)) + (syntmp-error-hook-95 + 'bound-identifier=? + "invalid argument" + syntmp-x-1417))) + (syntmp-bound-id=?-142 + syntmp-x-1414 + syntmp-y-1415)))) + (set! syntax-error + (lambda (syntmp-object-1419 . syntmp-messages-1418) + (begin + (for-each + (lambda (syntmp-x-1420) + (let ((syntmp-x-1421 syntmp-x-1420)) + (if (not (string? syntmp-x-1421)) + (syntmp-error-hook-95 + 'syntax-error + "invalid argument" + syntmp-x-1421)))) + syntmp-messages-1418) + (let ((syntmp-message-1422 + (if (null? syntmp-messages-1418) + "invalid syntax" + (apply string-append syntmp-messages-1418)))) + (syntmp-error-hook-95 + #f + syntmp-message-1422 + (syntmp-strip-165 + syntmp-object-1419 + '(()))))))) + (set! install-global-transformer + (lambda (syntmp-sym-1423 syntmp-v-1424) + (begin + (let ((syntmp-x-1425 syntmp-sym-1423)) + (if (not (symbol? syntmp-x-1425)) + (syntmp-error-hook-95 + 'define-syntax + "invalid argument" + syntmp-x-1425))) + (let ((syntmp-x-1426 syntmp-v-1424)) + (if (not (procedure? syntmp-x-1426)) + (syntmp-error-hook-95 + 'define-syntax + "invalid argument" + syntmp-x-1426))) + (syntmp-global-extend-116 + 'macro + syntmp-sym-1423 + syntmp-v-1424)))) + (letrec ((syntmp-match-1431 + (lambda (syntmp-e-1432 + syntmp-p-1433 + syntmp-w-1434 + syntmp-r-1435) + (cond ((not syntmp-r-1435) #f) + ((eq? syntmp-p-1433 (quote _)) syntmp-r-1435) + ((eq? syntmp-p-1433 (quote any)) + (cons (syntmp-wrap-146 syntmp-e-1432 syntmp-w-1434) + syntmp-r-1435)) + ((syntmp-syntax-object?-104 syntmp-e-1432) + (syntmp-match*-1430 + (let ((syntmp-e-1436 + (syntmp-syntax-object-expression-105 + syntmp-e-1432))) + (if (syntmp-annotation?-92 syntmp-e-1436) + (annotation-expression syntmp-e-1436) + syntmp-e-1436)) + syntmp-p-1433 + (syntmp-join-wraps-137 + syntmp-w-1434 + (syntmp-syntax-object-wrap-106 syntmp-e-1432)) + syntmp-r-1435)) + (else + (syntmp-match*-1430 + (let ((syntmp-e-1437 syntmp-e-1432)) + (if (syntmp-annotation?-92 syntmp-e-1437) + (annotation-expression syntmp-e-1437) + syntmp-e-1437)) + syntmp-p-1433 + syntmp-w-1434 + syntmp-r-1435))))) + (syntmp-match*-1430 + (lambda (syntmp-e-1438 + syntmp-p-1439 + syntmp-w-1440 + syntmp-r-1441) + (cond ((null? syntmp-p-1439) + (and (null? syntmp-e-1438) syntmp-r-1441)) + ((pair? syntmp-p-1439) + (and (pair? syntmp-e-1438) + (syntmp-match-1431 + (car syntmp-e-1438) + (car syntmp-p-1439) + syntmp-w-1440 + (syntmp-match-1431 + (cdr syntmp-e-1438) + (cdr syntmp-p-1439) + syntmp-w-1440 + syntmp-r-1441)))) + ((eq? syntmp-p-1439 (quote each-any)) + (let ((syntmp-l-1442 + (syntmp-match-each-any-1428 + syntmp-e-1438 + syntmp-w-1440))) + (and syntmp-l-1442 + (cons syntmp-l-1442 syntmp-r-1441)))) + (else + (let ((syntmp-t-1443 (vector-ref syntmp-p-1439 0))) + (if (memv syntmp-t-1443 (quote (each))) + (if (null? syntmp-e-1438) + (syntmp-match-empty-1429 + (vector-ref syntmp-p-1439 1) + syntmp-r-1441) + (let ((syntmp-l-1444 + (syntmp-match-each-1427 + syntmp-e-1438 + (vector-ref syntmp-p-1439 1) + syntmp-w-1440))) + (and syntmp-l-1444 + (let syntmp-collect-1445 ((syntmp-l-1446 + syntmp-l-1444)) + (if (null? (car syntmp-l-1446)) + syntmp-r-1441 + (cons (map car syntmp-l-1446) + (syntmp-collect-1445 + (map cdr syntmp-l-1446)))))))) + (if (memv syntmp-t-1443 (quote (free-id))) + (and (syntmp-id?-118 syntmp-e-1438) + (syntmp-free-id=?-141 + (syntmp-wrap-146 + syntmp-e-1438 + syntmp-w-1440) + (vector-ref syntmp-p-1439 1)) + syntmp-r-1441) + (if (memv syntmp-t-1443 (quote (atom))) + (and (equal? + (vector-ref syntmp-p-1439 1) + (syntmp-strip-165 + syntmp-e-1438 + syntmp-w-1440)) + syntmp-r-1441) + (if (memv syntmp-t-1443 (quote (vector))) + (and (vector? syntmp-e-1438) + (syntmp-match-1431 + (vector->list syntmp-e-1438) + (vector-ref syntmp-p-1439 1) + syntmp-w-1440 + syntmp-r-1441))))))))))) + (syntmp-match-empty-1429 + (lambda (syntmp-p-1447 syntmp-r-1448) + (cond ((null? syntmp-p-1447) syntmp-r-1448) + ((eq? syntmp-p-1447 (quote _)) syntmp-r-1448) + ((eq? syntmp-p-1447 (quote any)) + (cons (quote ()) syntmp-r-1448)) + ((pair? syntmp-p-1447) + (syntmp-match-empty-1429 + (car syntmp-p-1447) + (syntmp-match-empty-1429 + (cdr syntmp-p-1447) + syntmp-r-1448))) + ((eq? syntmp-p-1447 (quote each-any)) + (cons (quote ()) syntmp-r-1448)) + (else + (let ((syntmp-t-1449 (vector-ref syntmp-p-1447 0))) + (if (memv syntmp-t-1449 (quote (each))) + (syntmp-match-empty-1429 + (vector-ref syntmp-p-1447 1) + syntmp-r-1448) + (if (memv syntmp-t-1449 (quote (free-id atom))) + syntmp-r-1448 + (if (memv syntmp-t-1449 (quote (vector))) + (syntmp-match-empty-1429 + (vector-ref syntmp-p-1447 1) + syntmp-r-1448))))))))) + (syntmp-match-each-any-1428 + (lambda (syntmp-e-1450 syntmp-w-1451) + (cond ((syntmp-annotation?-92 syntmp-e-1450) + (syntmp-match-each-any-1428 + (annotation-expression syntmp-e-1450) + syntmp-w-1451)) + ((pair? syntmp-e-1450) + (let ((syntmp-l-1452 + (syntmp-match-each-any-1428 + (cdr syntmp-e-1450) + syntmp-w-1451))) + (and syntmp-l-1452 + (cons (syntmp-wrap-146 + (car syntmp-e-1450) + syntmp-w-1451) + syntmp-l-1452)))) + ((null? syntmp-e-1450) (quote ())) + ((syntmp-syntax-object?-104 syntmp-e-1450) + (syntmp-match-each-any-1428 + (syntmp-syntax-object-expression-105 + syntmp-e-1450) + (syntmp-join-wraps-137 + syntmp-w-1451 + (syntmp-syntax-object-wrap-106 syntmp-e-1450)))) + (else #f)))) + (syntmp-match-each-1427 + (lambda (syntmp-e-1453 syntmp-p-1454 syntmp-w-1455) + (cond ((syntmp-annotation?-92 syntmp-e-1453) + (syntmp-match-each-1427 + (annotation-expression syntmp-e-1453) + syntmp-p-1454 + syntmp-w-1455)) + ((pair? syntmp-e-1453) + (let ((syntmp-first-1456 + (syntmp-match-1431 + (car syntmp-e-1453) + syntmp-p-1454 + syntmp-w-1455 + '()))) + (and syntmp-first-1456 + (let ((syntmp-rest-1457 + (syntmp-match-each-1427 + (cdr syntmp-e-1453) + syntmp-p-1454 + syntmp-w-1455))) + (and syntmp-rest-1457 + (cons syntmp-first-1456 + syntmp-rest-1457)))))) + ((null? syntmp-e-1453) (quote ())) + ((syntmp-syntax-object?-104 syntmp-e-1453) + (syntmp-match-each-1427 + (syntmp-syntax-object-expression-105 + syntmp-e-1453) + syntmp-p-1454 + (syntmp-join-wraps-137 + syntmp-w-1455 + (syntmp-syntax-object-wrap-106 syntmp-e-1453)))) + (else #f))))) + (begin + (set! syntax-dispatch + (lambda (syntmp-e-1458 syntmp-p-1459) + (cond ((eq? syntmp-p-1459 (quote any)) + (list syntmp-e-1458)) + ((eq? syntmp-p-1459 (quote _)) (quote ())) + ((syntmp-syntax-object?-104 syntmp-e-1458) + (syntmp-match*-1430 + (let ((syntmp-e-1460 + (syntmp-syntax-object-expression-105 + syntmp-e-1458))) + (if (syntmp-annotation?-92 syntmp-e-1460) + (annotation-expression syntmp-e-1460) + syntmp-e-1460)) + syntmp-p-1459 + (syntmp-syntax-object-wrap-106 syntmp-e-1458) + '())) + (else + (syntmp-match*-1430 + (let ((syntmp-e-1461 syntmp-e-1458)) + (if (syntmp-annotation?-92 syntmp-e-1461) + (annotation-expression syntmp-e-1461) + syntmp-e-1461)) + syntmp-p-1459 + '(()) + '()))))) + (set! sc-chi syntmp-chi-154))))) -((lambda () - ((lambda () - (letrec ((g115 (lambda (g800) - ((letrec ((g801 (lambda (g804 g802 g803) - (if (pair? g804) - (g801 (cdr g804) - (cons (g94 (car g804) - g803) - g802) - g803) - (if (g66 g804) - (cons (g94 g804 g803) - g802) - (if (null? g804) - g802 - (if (g52 g804) - (g801 (g53 g804) - g802 - (g85 g803 - (g54 g804))) - (if (g43 g804) - (g801 (annotation-expression - g804) - g802 - g803) - (cons g804 - g802))))))))) - g801) - g800 - '() - '(())))) - (g114 (lambda (g322) - ((lambda (g323) (if (g43 g323) (gensym) (gensym))) - (if (g52 g322) (g53 g322) g322)))) - (g113 (lambda (g792 g791) - (if (memq 'top (g69 g791)) - (if ((lambda (g793) - (if g793 - g793 - (if (pair? g792) - (g43 (car g792)) - '#f))) - (g43 g792)) - (g112 g792 '#f) - g792) - ((letrec ((g794 (lambda (g795) - (if (g52 g795) - (g113 (g53 g795) - (g54 g795)) - (if (pair? g795) - ((lambda (g797 g796) - (if (if (eq? g797 - (car g795)) - (eq? g796 - (cdr g795)) - '#f) - g795 - (cons g797 - g796))) - (g794 (car g795)) - (g794 (cdr g795))) - (if (vector? g795) - ((lambda (g798) - ((lambda (g799) - (if (andmap - eq? - g798 - g799) - g795 - (list->vector - g799))) - (map g794 - g798))) - (vector->list - g795)) - g795)))))) - g794) - g792)))) - (g112 (lambda (g325 g324) - (if (pair? g325) - ((lambda (g326) - (begin (when g324 - (set-annotation-stripped! - g324 - g326)) - (set-car! g326 (g112 (car g325) '#f)) - (set-cdr! g326 (g112 (cdr g325) '#f)) - g326)) - (cons '#f '#f)) - (if (g43 g325) - ((lambda (g327) - (if g327 - g327 - (g112 (annotation-expression g325) - g325))) - (annotation-stripped g325)) - (if (vector? g325) - ((lambda (g328) - (begin (when g324 - (set-annotation-stripped! - g324 - g328)) - ((letrec ((g329 (lambda (g330) - (unless (g42 g330 - '0) - (vector-set! - g328 - g330 - (g112 (vector-ref - g325 - g330) - '#f)) - (g329 (g40 g330 - '1)))))) - g329) - (- (vector-length g325) '1)) - g328)) - (make-vector (vector-length g325))) - g325))))) - (g111 (lambda (g790) - (if (g65 g790) - (g89 g790 - '#(syntax-object - ... - ((top) - #(ribcage () () ()) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("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 - self-evaluating? - build-lexical-var - build-letrec - 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)) - ("i" "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "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")) - #(ribcage - (define-structure) - ((top)) - ("i"))))) - '#f))) - (g110 (lambda () (list 'void))) - (g109 (lambda (g788) - ((lambda (g789) - (if (procedure? g789) - g789 - (syntax-error - g789 - '"nonprocedure transfomer"))) - (g45 g788)))) - (g108 (lambda (g336 g331 g335 g332 g334 g333) - ((lambda (g337) - ((lambda (g338) - (if g338 - (apply - (lambda (g343 g339 g342 g340 g341) - ((lambda (g344) - (if (not (g91 g344)) - (syntax-error - g331 - '"duplicate bound keyword in") - ((lambda (g345) - ((lambda (g346) - (g333 (cons g340 g341) - (g60 g345 - ((lambda (g348 - g347) - (map (lambda (g350) - (cons 'macro - (g109 (g102 g350 - g347 - g348)))) - g342)) - (if g336 - g346 - g332) - (g62 g335)) - g335) - g346 - g334)) - (g83 g344 g345 g332))) - (g72 g344)))) - g339)) - g338) - ((lambda (g353) - (syntax-error (g95 g331 g332 g334))) - g337))) - (syntax-dispatch - g337 - '(any #(each (any any)) any . each-any)))) - g331))) - (g107 (lambda (g765 g761 g764 g762 g763) - ((lambda (g766) - ((lambda (g767) - (if g767 - (apply - (lambda (g770 g768 g769) - ((lambda (g771) - (if (not (g91 g771)) - (syntax-error - g765 - '"invalid parameter list in") - ((lambda (g773 g772) - (g763 g772 - (g106 (cons g768 g769) - g765 - (g61 g773 - g772 - g764) - (g83 g771 - g773 - g762)))) - (g72 g771) - (map g114 g771)))) - g770)) - g767) - ((lambda (g776) - (if g776 - (apply - (lambda (g779 g777 g778) - ((lambda (g780) - (if (not (g91 g780)) - (syntax-error - g765 - '"invalid parameter list in") - ((lambda (g782 g781) - (g763 ((letrec ((g784 (lambda (g786 - g785) - (if (null? - g786) - g785 - (g784 (cdr g786) - (cons (car g786) - g785)))))) - g784) - (cdr g781) - (car g781)) - (g106 (cons g777 - g778) - g765 - (g61 g782 - g781 - g764) - (g83 g780 - g782 - g762)))) - (g72 g780) - (map g114 g780)))) - (g115 g779))) - g776) - ((lambda (g787) - (syntax-error g765)) - g766))) - (syntax-dispatch - g766 - '(any any . each-any))))) - (syntax-dispatch - g766 - '(each-any any . each-any)))) - g761))) - (g106 (lambda (g357 g354 g356 g355) - ((lambda (g358) - ((lambda (g359) - ((lambda (g360) - ((lambda () - ((letrec ((g361 (lambda (g367 - g362 - g366 - g363 - g365 - g364) - (if (null? g367) - (syntax-error - g354 - '"no expressions in body") - ((lambda (g369 - g368) - (call-with-values - (lambda () - (g100 g369 - g368 - '(()) - '#f - g359)) - (lambda (g374 - g370 - g373 - g371 - g372) - ((lambda (g375) - (if (memv g375 - '(define-form)) - ((lambda (g377 - g376) - ((lambda (g378) - (begin (g82 g359 - g377 - g376) - (g361 (cdr g367) - (cons g377 - g362) - (cons g376 - g366) - (cons g378 - g363) - (cons (cons g368 - (g94 g373 - g371)) - g365) - (cons (cons 'lexical - g378) - g364)))) - (g114 g377))) - (g94 g370 - g371) - (g71)) - (if (memv g375 - '(define-syntax-form)) - ((lambda (g380 - g379) - (begin (g82 g359 - g380 - g379) - (g361 (cdr g367) - (cons g380 - g362) - (cons g379 - g366) - g363 - g365 - (cons (cons 'macro - (cons g368 - (g94 g373 - g371))) - g364)))) - (g94 g370 - g371) - (g71)) - (if (memv g375 - '(begin-form)) - ((lambda (g381) - ((lambda (g382) - (if g382 - (apply - (lambda (g384 - g383) - (g361 ((letrec ((g385 (lambda (g386) - (if (null? - g386) - (cdr g367) - (cons (cons g368 - (g94 (car g386) - g371)) - (g385 (cdr g386))))))) - g385) - g383) - g362 - g366 - g363 - g365 - g364)) - g382) - (syntax-error - g381))) - (syntax-dispatch - g381 - '(any . - each-any)))) - g373) - (if (memv g375 - '(local-syntax-form)) - (g108 g370 - g373 - g368 - g371 - g372 - (lambda (g391 - g388 - g390 - g389) - (g361 ((letrec ((g392 (lambda (g393) - (if (null? - g393) - (cdr g367) - (cons (cons g388 - (g94 (car g393) - g390)) - (g392 (cdr g393))))))) - g392) - g391) - g362 - g366 - g363 - g365 - g364))) - (if (null? - g362) - (g49 '#f - (map (lambda (g394) - (g102 (cdr g394) - (car g394) - '(()))) - (cons (cons g368 - (g95 g373 - g371 - g372)) - (cdr g367)))) - (begin (if (not (g91 g362)) - (syntax-error - g354 - '"invalid or duplicate identifier in definition") - (void)) - ((letrec ((g395 (lambda (g398 - g396 - g397) - (if (not (null? - g398)) - ((lambda (g399) - ((lambda () - (if (eq? (car g399) - 'macro) - ((lambda (g400) - ((lambda (g401) - ((lambda () - (begin (set-cdr! - g399 - (g109 (g102 (cddr g399) - g401 - '(())))) - (g395 (cdr g398) - g400 - g401))))) - (if (eq? g400 - g396) - g397 - (g62 g400)))) - (cadr g399)) - (g395 (cdr g398) - g396 - g397))))) - (car g398)) - (void))))) - g395) - g364 - '#f - '#f) - (set-cdr! - g358 - (g60 g366 - g364 - (cdr g358))) - (g50 '#f - g363 - (map (lambda (g403) - (g102 (cdr g403) - (car g403) - '(()))) - g365) - (g49 '#f - (map (lambda (g402) - (g102 (cdr g402) - (car g402) - '(()))) - (cons (cons g368 - (g95 g373 - g371 - g372)) - (cdr g367)))))))))))) - g374)))) - (cdar g367) - (caar g367)))))) - g361) - (map (lambda (g404) - (cons g358 (g94 g404 g360))) - g357) - '() - '() - '() - '() - '())))) - (g68 (g69 g355) (cons g359 (g70 g355))))) - (g73 '() '() '()))) - (cons '("placeholder" placeholder) g356)))) - (g105 (lambda (g750 g746 g749 g747 g748) - (letrec ((g751 (lambda (g753 g752) - (if (pair? g753) - (cons (g751 (car g753) g752) - (g751 (cdr g753) g752)) - (if (g52 g753) - ((lambda (g754) - ((lambda (g756 g755) - (g51 (g53 g753) - (if (if (pair? - g756) - (eq? (car g756) - '#f) - '#f) - (g68 (cdr g756) - (if g748 - (cons g748 - (cdr g755)) - (cdr g755))) - (g68 (cons g752 - g756) - (if g748 - (cons g748 - (cons 'shift - g755)) - (cons 'shift - g755)))))) - (g69 g754) - (g70 g754))) - (g54 g753)) - (if (vector? g753) - ((lambda (g757) - ((lambda (g758) - ((lambda () - ((letrec ((g759 (lambda (g760) - (if (g41 g760 - g757) - g758 - (begin (vector-set! - g758 - g760 - (g751 (vector-ref - g753 - g760) - g752)) - (g759 (g39 g760 - '1))))))) - g759) - '0)))) - (make-vector - g757))) - (vector-length g753)) - (if (symbol? g753) - (syntax-error - g753 - '"encountered raw symbol in macro output") - g753))))))) - (g751 (g750 (g94 g746 (g81 g747))) - (string '#\m))))) - (g104 (lambda (g409 g405 g408 g406 g407) - ((lambda (g410) - ((lambda (g411) - (if g411 - (apply - (lambda (g413 g412) - (cons g409 - (map (lambda (g415) - (g102 g415 g408 g406)) - g412))) - g411) - (syntax-error g410))) - (syntax-dispatch g410 '(any . each-any)))) - g405))) - (g103 (lambda (g729 g724 g728 g725 g727 g726) - ((lambda (g730) - (if (memv g730 '(lexical)) - g724 - (if (memv g730 '(core)) - (g724 g728 g725 g727 g726) - (if (memv g730 '(lexical-call)) - (g104 g724 g728 g725 g727 g726) - (if (memv g730 '(global-call)) - (g104 g724 g728 g725 g727 g726) - (if (memv g730 '(constant)) - (list 'quote - (g113 (g95 g728 - g727 - g726) - '(()))) - (if (memv g730 '(global)) - g724 - (if (memv g730 '(call)) - (g104 (g102 (car g728) - g725 - g727) - g728 - g725 - g727 - g726) - (if (memv g730 - '(begin-form)) - ((lambda (g731) - ((lambda (g732) - (if g732 - (apply - (lambda (g735 - g733 - g734) - (g96 (cons g733 - g734) - g725 - g727 - g726)) - g732) - (syntax-error - g731))) - (syntax-dispatch - g731 - '(any any - . - each-any)))) - g728) - (if (memv g730 - '(local-syntax-form)) - (g108 g724 - g728 - g725 - g727 - g726 - g96) - (if (memv g730 - '(eval-when-form)) - ((lambda (g737) - ((lambda (g738) - (if g738 - (apply - (lambda (g742 - g739 - g741 - g740) - ((lambda (g743) - (if (memq 'eval - g743) - (g96 (cons g741 - g740) - g725 - g727 - g726) - (g110))) - (g99 g728 - g739 - g727))) - g738) - (syntax-error - g737))) - (syntax-dispatch - g737 - '(any each-any - any - . - each-any)))) - g728) - (if (memv g730 - '(define-form - define-syntax-form)) - (syntax-error - (g94 g724 - g727) - '"invalid context for definition of") - (if (memv g730 - '(syntax)) - (syntax-error - (g95 g728 - g727 - g726) - '"reference to pattern variable outside syntax form") - (if (memv g730 - '(displaced-lexical)) - (syntax-error - (g95 g728 - g727 - g726) - '"reference to identifier outside its scope") - (syntax-error - (g95 g728 - g727 - g726)))))))))))))))) - g729))) - (g102 (lambda (g418 g416 g417) - (call-with-values - (lambda () (g100 g418 g416 g417 '#f '#f)) - (lambda (g423 g419 g422 g420 g421) - (g103 g423 g419 g422 g416 g420 g421))))) - (g101 (lambda (g678 g674 g677 g675 g676) - (call-with-values - (lambda () (g100 g678 g674 g677 '#f '#f)) - (lambda (g689 g685 g688 g686 g687) - ((lambda (g690) - (if (memv g690 '(begin-form)) - ((lambda (g691) - ((lambda (g692) - (if g692 - (apply - (lambda (g693) (g110)) - g692) - ((lambda (g694) - (if g694 - (apply - (lambda (g697 - g695 - g696) - (g97 (cons g695 - g696) - g674 - g686 - g687 - g675 - g676)) - g694) - (syntax-error g691))) - (syntax-dispatch - g691 - '(any any . each-any))))) - (syntax-dispatch g691 '(any)))) - g688) - (if (memv g690 '(local-syntax-form)) - (g108 g685 - g688 - g674 - g686 - g687 - (lambda (g702 g699 g701 g700) - (g97 g702 - g699 - g701 - g700 - g675 - g676))) - (if (memv g690 '(eval-when-form)) - ((lambda (g703) - ((lambda (g704) - (if g704 - (apply - (lambda (g708 - g705 - g707 - g706) - ((lambda (g710 - g709) - (if (eq? g675 - 'e) - (if (memq 'eval - g710) - (g97 g709 - g674 - g686 - g687 - 'e - '(eval)) - (g110)) - (if (memq 'load - g710) - (if ((lambda (g711) - (if g711 - g711 - (if (eq? g675 - 'c&e) - (memq 'eval - g710) - '#f))) - (memq 'compile - g710)) - (g97 g709 - g674 - g686 - g687 - 'c&e - '(compile - load)) - (if (memq g675 - '(c c&e)) - (g97 g709 - g674 - g686 - g687 - 'c - '(load)) - (g110))) - (if ((lambda (g712) - (if g712 - g712 - (if (eq? g675 - 'c&e) - (memq 'eval - g710) - '#f))) - (memq 'compile - g710)) - (begin (g44 (g97 g709 - g674 - g686 - g687 - 'e - '(eval))) - (g110)) - (g110))))) - (g99 g688 - g705 - g686) - (cons g707 g706))) - g704) - (syntax-error g703))) - (syntax-dispatch - g703 - '(any each-any - any - . - each-any)))) - g688) - (if (memv g690 - '(define-syntax-form)) - ((lambda (g716 g715) - ((lambda (g717) - (if (memv g717 '(c)) - (if (memq 'compile - g676) - ((lambda (g718) - (begin (g44 g718) - (if (memq 'load - g676) - g718 - (g110)))) - (g98 g716 - (g102 g688 - g715 - g686))) - (if (memq 'load - g676) - (g98 g716 - (g102 g688 - g715 - g686)) - (g110))) - (if (memv g717 - '(c&e)) - ((lambda (g719) - (begin (g44 g719) - g719)) - (g98 g716 - (g102 g688 - g715 - g686))) - (begin (if (memq 'eval - g676) - (g44 (g98 g716 - (g102 g688 - g715 - g686))) - (void)) - (g110))))) - g675)) - (g88 g685 g686) - (g62 g674)) - (if (memv g690 - '(define-form)) - ((lambda (g720) - ((lambda (g721) - (if (memv g721 - '(global)) - ((lambda (g722) - (begin (if (eq? g675 - 'c&e) - (g44 g722) - (void)) - g722)) - (list 'define - g720 - (g102 g688 - g674 - g686))) - (if (memv g721 - '(displaced-lexical)) - (syntax-error - (g94 g685 - g686) - '"identifier out of context") - (syntax-error - (g94 g685 - g686) - '"cannot define keyword at top level")))) - (g58 (g63 g720 - g674)))) - (g88 g685 g686)) - ((lambda (g723) - (begin (if (eq? g675 - 'c&e) - (g44 g723) - (void)) - g723)) - (g103 g689 - g685 - g688 - g674 - g686 - g687)))))))) - g689))))) - (g100 (lambda (g428 g424 g427 g425 g426) - (if (symbol? g428) - ((lambda (g429) - ((lambda (g430) - ((lambda (g431) - ((lambda () - ((lambda (g432) - (if (memv g432 '(lexical)) - (values - g431 - (g59 g430) - g428 - g427 - g425) - (if (memv g432 '(global)) - (values - g431 - g429 - g428 - g427 - g425) - (if (memv g432 '(macro)) - (g100 (g105 (g59 g430) - g428 - g424 - g427 - g426) - g424 - '(()) - g425 - g426) - (values - g431 - (g59 g430) - g428 - g427 - g425))))) - g431)))) - (g58 g430))) - (g63 g429 g424))) - (g88 g428 g427)) - (if (pair? g428) - ((lambda (g433) - (if (g66 g433) - ((lambda (g434) - ((lambda (g435) - ((lambda (g436) - ((lambda () - ((lambda (g437) - (if (memv g437 - '(lexical)) - (values - 'lexical-call - (g59 g435) - g428 - g427 - g425) - (if (memv g437 - '(global)) - (values - 'global-call - g434 - g428 - g427 - g425) - (if (memv g437 - '(macro)) - (g100 (g105 (g59 g435) - g428 - g424 - g427 - g426) - g424 - '(()) - g425 - g426) - (if (memv g437 - '(core)) - (values - g436 - (g59 g435) - g428 - g427 - g425) - (if (memv g437 - '(local-syntax)) - (values - 'local-syntax-form - (g59 g435) - g428 - g427 - g425) - (if (memv g437 - '(begin)) - (values - 'begin-form - '#f - g428 - g427 - g425) - (if (memv g437 - '(eval-when)) - (values - 'eval-when-form - '#f - g428 - g427 - g425) - (if (memv g437 - '(define)) - ((lambda (g438) - ((lambda (g439) - (if (if g439 - (apply - (lambda (g442 - g440 - g441) - (g66 g440)) - g439) - '#f) - (apply - (lambda (g445 - g443 - g444) - (values - 'define-form - g443 - g444 - g427 - g425)) - g439) - ((lambda (g446) - (if (if g446 - (apply - (lambda (g451 - g447 - g450 - g448 - g449) - (if (g66 g447) - (g91 (g115 g450)) - '#f)) - g446) - '#f) - (apply - (lambda (g456 - g452 - g455 - g453 - g454) - (values - 'define-form - (g94 g452 - g427) - (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 - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(type) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(b) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(n) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(first) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(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 - self-evaluating? - build-lexical-var - build-letrec - 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)) - ("i" "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "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")) - #(ribcage - (define-structure) - ((top)) - ("i")))) - (g94 (cons g455 - (cons g453 - g454)) - g427)) - '(()) - g425)) - g446) - ((lambda (g458) - (if (if g458 - (apply - (lambda (g460 - g459) - (g66 g459)) - g458) - '#f) - (apply - (lambda (g462 - g461) - (values - 'define-form - (g94 g461 - g427) - '(#(syntax-object - void - ((top) - #(ribcage - #(_ - name) - #((top) - (top)) - #("i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(t) - #(("m" top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(type) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(b) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(n) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(first) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(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 - self-evaluating? - build-lexical-var - build-letrec - 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)) - ("i" "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "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")) - #(ribcage - (define-structure) - ((top)) - ("i"))))) - '(()) - g425)) - g458) - (syntax-error - g438))) - (syntax-dispatch - g438 - '(any any))))) - (syntax-dispatch - g438 - '(any (any . - any) - any - . - each-any))))) - (syntax-dispatch - g438 - '(any any - any)))) - g428) - (if (memv g437 - '(define-syntax)) - ((lambda (g463) - ((lambda (g464) - (if (if g464 - (apply - (lambda (g467 - g465 - g466) - (g66 g465)) - g464) - '#f) - (apply - (lambda (g470 - g468 - g469) - (values - 'define-syntax-form - g468 - g469 - g427 - g425)) - g464) - (syntax-error - g463))) - (syntax-dispatch - g463 - '(any any - any)))) - g428) - (values - 'call - '#f - g428 - g427 - g425))))))))))) - g436)))) - (g58 g435))) - (g63 g434 g424))) - (g88 g433 g427)) - (values 'call '#f g428 g427 g425))) - (car g428)) - (if (g52 g428) - (g100 (g53 g428) - g424 - (g85 g427 (g54 g428)) - '#f - g426) - (if (g43 g428) - (g100 (annotation-expression g428) - g424 - g427 - (annotation-source g428) - g426) - (if ((lambda (g471) - ((lambda (g472) - (if g472 - g472 - ((lambda (g473) - (if g473 - g473 - ((lambda (g474) - (if g474 - g474 - ((lambda (g475) - (if g475 - g475 - (null? - g471))) - (char? - g471)))) - (string? - g471)))) - (number? g471)))) - (boolean? g471))) - g428) - (values - 'constant - '#f - g428 - g427 - g425) - (values - 'other - '#f - g428 - g427 - g425)))))))) - (g99 (lambda (g669 g667 g668) - ((letrec ((g670 (lambda (g672 g671) - (if (null? g672) - g671 - (g670 (cdr g672) - (cons ((lambda (g673) - (if (g89 g673 - '#(syntax-object - compile - ((top) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(when-list - situations) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(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 - self-evaluating? - build-lexical-var - build-letrec - 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)) - ("i" "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "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")) - #(ribcage - (define-structure) - ((top)) - ("i"))))) - 'compile - (if (g89 g673 - '#(syntax-object - load - ((top) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(when-list - situations) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(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 - self-evaluating? - build-lexical-var - build-letrec - 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)) - ("i" "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "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")) - #(ribcage - (define-structure) - ((top)) - ("i"))))) - 'load - (if (g89 g673 - '#(syntax-object - eval - ((top) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(when-list - situations) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(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 - self-evaluating? - build-lexical-var - build-letrec - 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)) - ("i" "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "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")) - #(ribcage - (define-structure) - ((top)) - ("i"))))) - 'eval - (syntax-error - (g94 g673 - g668) - '"invalid eval-when situation"))))) - (car g672)) - g671)))))) - g670) - g667 - '()))) - (g98 (lambda (g477 g476) - (list 'install-global-transformer - (list 'quote g477) - g476))) - (g97 (lambda (g659 g654 g658 g655 g657 g656) - (g49 g655 - ((letrec ((g660 (lambda (g665 - g661 - g664 - g662 - g663) - (if (null? g665) - '() - ((lambda (g666) - (cons g666 - (g660 (cdr g665) - g661 - g664 - g662 - g663))) - (g101 (car g665) - g661 - g664 - g662 - g663)))))) - g660) - g659 - g654 - g658 - g657 - g656)))) - (g96 (lambda (g481 g478 g480 g479) - (g49 g479 - ((letrec ((g482 (lambda (g485 g483 g484) - (if (null? g485) - '() - ((lambda (g486) - (cons g486 - (g482 (cdr g485) - g483 - g484))) - (g102 (car g485) - g483 - g484)))))) - g482) - g481 - g478 - g480)))) - (g95 (lambda (g653 g651 g652) - (g94 (if g652 (make-annotation g653 g652 '#f) g653) - g651))) - (g94 (lambda (g488 g487) - (if (if (null? (g69 g487)) (null? (g70 g487)) '#f) - g488 - (if (g52 g488) - (g51 (g53 g488) (g85 g487 (g54 g488))) - (if (null? g488) g488 (g51 g488 g487)))))) - (g93 (lambda (g649 g648) - (if (not (null? g648)) - ((lambda (g650) - (if g650 g650 (g93 g649 (cdr g648)))) - (g90 g649 (car g648))) - '#f))) - (g92 (lambda (g489) - ((letrec ((g490 (lambda (g491) - ((lambda (g492) - (if g492 - g492 - (if (not (g93 (car g491) - (cdr g491))) - (g490 (cdr g491)) - '#f))) - (null? g491))))) - g490) - g489))) - (g91 (lambda (g644) - (if ((letrec ((g645 (lambda (g646) - ((lambda (g647) - (if g647 - g647 - (if (g66 (car g646)) - (g645 (cdr g646)) - '#f))) - (null? g646))))) - g645) - g644) - (g92 g644) - '#f))) - (g90 (lambda (g494 g493) - (if (if (g52 g494) (g52 g493) '#f) - (if (eq? ((lambda (g496) - (if (g43 g496) - (annotation-expression g496) - g496)) - (g53 g494)) - ((lambda (g495) - (if (g43 g495) - (annotation-expression g495) - g495)) - (g53 g493))) - (g87 (g69 (g54 g494)) (g69 (g54 g493))) - '#f) - (eq? ((lambda (g498) - (if (g43 g498) - (annotation-expression g498) - g498)) - g494) - ((lambda (g497) - (if (g43 g497) - (annotation-expression g497) - g497)) - g493))))) - (g89 (lambda (g639 g638) - (if (eq? ((lambda (g642) - ((lambda (g643) - (if (g43 g643) - (annotation-expression g643) - g643)) - (if (g52 g642) (g53 g642) g642))) - g639) - ((lambda (g640) - ((lambda (g641) - (if (g43 g641) - (annotation-expression g641) - g641)) - (if (g52 g640) (g53 g640) g640))) - g638)) - (eq? (g88 g639 '(())) (g88 g638 '(()))) - '#f))) - (g88 (lambda (g500 g499) - (letrec ((g503 (lambda (g526 g522 g525 g523 g524) - ((lambda (g527) - ((letrec ((g528 (lambda (g529) - (if (g41 g529 - g527) - (g501 g526 - (cdr g522) - g525) - (if (if (eq? (vector-ref - g523 - g529) - g526) - (g87 g525 - (vector-ref - (g76 g524) - g529)) - '#f) - (values - (vector-ref - (g77 g524) - g529) - g525) - (g528 (g39 g529 - '1))))))) - g528) - '0)) - (vector-length g523)))) - (g502 (lambda (g513 g509 g512 g510 g511) - ((letrec ((g514 (lambda (g516 g515) - (if (null? g516) - (g501 g513 - (cdr g509) - g512) - (if (if (eq? (car g516) - g513) - (g87 g512 - (list-ref - (g76 g511) - g515)) - '#f) - (values - (list-ref - (g77 g511) - g515) - g512) - (g514 (cdr g516) - (g39 g515 - '1))))))) - g514) - g510 - '0))) - (g501 (lambda (g519 g517 g518) - (if (null? g517) - (values '#f g518) - ((lambda (g520) - (if (eq? g520 'shift) - (g501 g519 - (cdr g517) - (cdr g518)) - ((lambda (g521) - (if (vector? g521) - (g503 g519 - g517 - g518 - g521 - g520) - (g502 g519 - g517 - g518 - g521 - g520))) - (g75 g520)))) - (car g517)))))) - (if (symbol? g500) - ((lambda (g530) (if g530 g530 g500)) - (call-with-values - (lambda () - (g501 g500 (g70 g499) (g69 g499))) - (lambda (g531 . g532) g531))) - (if (g52 g500) - ((lambda (g534 g533) - ((lambda (g535) - (call-with-values - (lambda () - (g501 g534 (g70 g499) g535)) - (lambda (g537 g536) - ((lambda (g538) - (if g538 - g538 - ((lambda (g539) - (if g539 g539 g534)) - (call-with-values - (lambda () - (g501 g534 - (g70 g533) - g536)) - (lambda (g540 . g541) - g540))))) - g537)))) - (g86 (g69 g499) (g69 g533)))) - ((lambda (g542) - (if (g43 g542) - (annotation-expression g542) - g542)) - (g53 g500)) - (g54 g500)) - (if (g43 g500) - ((lambda (g543) - ((lambda (g544) (if g544 g544 g543)) - (call-with-values - (lambda () - (g501 g543 - (g70 g499) - (g69 g499))) - (lambda (g545 . g546) g545)))) - ((lambda (g547) - (if (g43 g547) - (annotation-expression g547) - g547)) - g500)) - (g46 'id-var-name - '"invalid id" - g500))))))) - (g87 (lambda (g636 g635) - ((lambda (g637) - (if g637 - g637 - (if (not (null? g636)) - (if (not (null? g635)) - (if (eq? (car g636) (car g635)) - (g87 (cdr g636) (cdr g635)) - '#f) - '#f) - '#f))) - (eq? g636 g635)))) - (g86 (lambda (g549 g548) (g84 g549 g548))) - (g85 (lambda (g632 g631) - ((lambda (g634 g633) - (if (null? g634) - (if (null? g633) - g631 - (g68 (g69 g631) (g84 g633 (g70 g631)))) - (g68 (g84 g634 (g69 g631)) - (g84 g633 (g70 g631))))) - (g69 g632) - (g70 g632)))) - (g84 (lambda (g551 g550) - (if (null? g550) g551 (append g551 g550)))) - (g83 (lambda (g621 g619 g620) - (if (null? g621) - g620 - (g68 (g69 g620) - (cons ((lambda (g622) - ((lambda (g623) - ((lambda (g625 g624) - (begin ((letrec ((g626 (lambda (g628 - g627) - (if (not (null? - g628)) - (call-with-values - (lambda () - (g67 (car g628) - g620)) - (lambda (g630 - g629) - (begin (vector-set! - g625 - g627 - g630) - (vector-set! - g624 - g627 - g629) - (g626 (cdr g628) - (g39 g627 - '1))))) - (void))))) - g626) - g621 - '0) - (g73 g625 g624 g622))) - (make-vector g623) - (make-vector g623))) - (vector-length g622))) - (list->vector g619)) - (g70 g620)))))) - (g82 (lambda (g554 g552 g553) - (begin (g78 g554 - (cons ((lambda (g555) - (if (g43 g555) - (annotation-expression g555) - g555)) - (g53 g552)) - (g75 g554))) - (g79 g554 (cons (g69 (g54 g552)) (g76 g554))) - (g80 g554 (cons g553 (g77 g554)))))) - (g81 (lambda (g618) - (g68 (cons '#f (g69 g618)) (cons 'shift (g70 g618))))) - (g80 (lambda (g557 g556) (vector-set! g557 '3 g556))) - (g79 (lambda (g617 g616) (vector-set! g617 '2 g616))) - (g78 (lambda (g559 g558) (vector-set! g559 '1 g558))) - (g77 (lambda (g615) (vector-ref g615 '3))) - (g76 (lambda (g560) (vector-ref g560 '2))) - (g75 (lambda (g614) (vector-ref g614 '1))) - (g74 (lambda (g561) - (if (vector? g561) - (if (= (vector-length g561) '4) - (eq? (vector-ref g561 '0) 'ribcage) - '#f) - '#f))) - (g73 (lambda (g613 g611 g612) - (vector 'ribcage g613 g611 g612))) - (g72 (lambda (g562) - (if (null? g562) '() (cons (g71) (g72 (cdr g562)))))) - (g71 (lambda () (string '#\i))) - (g70 cdr) - (g69 car) - (g68 cons) - (g67 (lambda (g608 g607) - (if (g52 g608) - (values - ((lambda (g609) - (if (g43 g609) - (annotation-expression g609) - g609)) - (g53 g608)) - (g86 (g69 g607) (g69 (g54 g608)))) - (values - ((lambda (g610) - (if (g43 g610) - (annotation-expression g610) - g610)) - g608) - (g69 g607))))) - (g66 (lambda (g563) - (if (symbol? g563) - '#t - (if (g52 g563) - (symbol? - ((lambda (g564) - (if (g43 g564) - (annotation-expression g564) - g564)) - (g53 g563))) - (if (g43 g563) - (symbol? (annotation-expression g563)) - '#f))))) - (g65 (lambda (g605) - (if (g52 g605) - (symbol? - ((lambda (g606) - (if (g43 g606) - (annotation-expression g606) - g606)) - (g53 g605))) - '#f))) - (g64 (lambda (g567 g565 g566) (g47 g565 (cons g567 g566)))) - (g63 (lambda (g602 g601) - ((lambda (g603) - (if g603 - (cdr g603) - (if (symbol? g602) - ((lambda (g604) (if g604 g604 '(global))) - (g48 g602)) - '(displaced-lexical)))) - (assq g602 g601)))) - (g62 (lambda (g568) - (if (null? g568) - '() - ((lambda (g569) - (if (eq? (cadr g569) 'macro) - (cons g569 (g62 (cdr g568))) - (g62 (cdr g568)))) - (car g568))))) - (g61 (lambda (g600 g598 g599) - (if (null? g600) - g599 - (g61 (cdr g600) - (cdr g598) - (cons (cons (car g600) - (cons 'lexical (car g598))) - g599))))) - (g60 (lambda (g572 g570 g571) - (if (null? g572) - g571 - (g60 (cdr g572) - (cdr g570) - (cons (cons (car g572) (car g570)) g571))))) - (g59 cdr) - (g58 car) - (g57 (lambda (g597) - (if (g43 g597) - (annotation-source g597) - (if (g52 g597) (g57 (g53 g597)) '#f)))) - (g56 (lambda (g574 g573) (vector-set! g574 '2 g573))) - (g55 (lambda (g596 g595) (vector-set! g596 '1 g595))) - (g54 (lambda (g575) (vector-ref g575 '2))) - (g53 (lambda (g594) (vector-ref g594 '1))) - (g52 (lambda (g576) - (if (vector? g576) - (if (= (vector-length g576) '3) - (eq? (vector-ref g576 '0) 'syntax-object) - '#f) - '#f))) - (g51 (lambda (g593 g592) (vector 'syntax-object g593 g592))) - (g50 (lambda (g580 g577 g579 g578) - (if (null? g577) - g578 - (list 'letrec (map list g577 g579) g578)))) - (g49 (lambda (g591 g590) - (if (null? (cdr g590)) - (car g590) - (cons 'begin g590)))) - (g48 (lambda (g581) (getprop g581 '*sc-expander*))) - (g47 (lambda (g589 g588) (putprop g589 '*sc-expander* g588))) - (g46 (lambda (g584 g582 g583) - (error g584 '"~a ~s" g582 g583))) - (g45 (lambda (g587) - (eval (list g38 g587) (interaction-environment)))) - (g44 (lambda (g585) - (eval (list g38 g585) (interaction-environment)))) - (g43 (lambda (g586) '#f)) - (g42 <) - (g41 =) - (g40 -) - (g39 +) - (g38 '"noexpand")) - (begin (g64 'local-syntax 'letrec-syntax '#t) - (g64 'local-syntax 'let-syntax '#f) - (g64 'core - 'fluid-let-syntax - (lambda (g1137 g1134 g1136 g1135) - ((lambda (g1138) - ((lambda (g1139) - (if (if g1139 - (apply - (lambda (g1144 - g1140 - g1143 - g1141 - g1142) - (g91 g1140)) - g1139) - '#f) - (apply - (lambda (g1150 g1146 g1149 g1147 g1148) - ((lambda (g1151) - (begin (for-each - (lambda (g1158 g1157) - ((lambda (g1159) - (if (memv g1159 - '(displaced-lexical)) - (syntax-error - (g95 g1158 - g1136 - g1135) - '"identifier out of context") - (void))) - (g58 (g63 g1157 - g1134)))) - g1146 - g1151) - (g106 (cons g1147 g1148) - (g95 g1137 g1136 g1135) - (g60 g1151 - ((lambda (g1152) - (map (lambda (g1154) - (cons 'macro - (g109 (g102 g1154 - g1152 - g1136)))) - g1149)) - (g62 g1134)) - g1134) - g1136))) - (map (lambda (g1161) - (g88 g1161 g1136)) - g1146))) - g1139) - ((lambda (g1162) - (syntax-error (g95 g1137 g1136 g1135))) - g1138))) - (syntax-dispatch - g1138 - '(any #(each (any any)) any . each-any)))) - g1137))) - (g64 'core - 'quote - (lambda (g808 g805 g807 g806) - ((lambda (g809) - ((lambda (g810) - (if g810 - (apply - (lambda (g812 g811) - (list 'quote (g113 g811 g807))) - g810) - ((lambda (g813) - (syntax-error (g95 g808 g807 g806))) - g809))) - (syntax-dispatch g809 '(any any)))) - g808))) - (g64 'core - 'syntax - ((lambda () - (letrec ((g1036 (lambda (g1119) - ((lambda (g1120) - (if (memv g1120 '(ref)) - (cadr g1119) - (if (memv g1120 - '(primitive)) - (cadr g1119) - (if (memv g1120 - '(quote)) - (list 'quote - (cadr g1119)) - (if (memv g1120 - '(lambda)) - (list 'lambda - (cadr g1119) - (g1036 - (caddr - g1119))) - (if (memv g1120 - '(map)) - ((lambda (g1121) - (cons (if (g41 (length - g1121) - '2) - 'map - 'map) - g1121)) - (map g1036 - (cdr g1119))) - (cons (car g1119) - (map g1036 - (cdr g1119))))))))) - (car g1119)))) - (g1035 (lambda (g1037) - (if (eq? (car g1037) 'list) - (cons 'vector (cdr g1037)) - (if (eq? (car g1037) 'quote) - (list 'quote - (list->vector - (cadr g1037))) - (list 'list->vector - g1037))))) - (g1034 (lambda (g1118 g1117) - (if (equal? g1117 ''()) - g1118 - (list 'append g1118 g1117)))) - (g1033 (lambda (g1039 g1038) - ((lambda (g1040) - (if (memv g1040 '(quote)) - (if (eq? (car g1039) - 'quote) - (list 'quote - (cons (cadr g1039) - (cadr g1038))) - (if (eq? (cadr g1038) - '()) - (list 'list g1039) - (list 'cons - g1039 - g1038))) - (if (memv g1040 '(list)) - (cons 'list - (cons g1039 - (cdr g1038))) - (list 'cons - g1039 - g1038)))) - (car g1038)))) - (g1032 (lambda (g1110 g1109) - ((lambda (g1112 g1111) - (if (eq? (car g1110) 'ref) - (car g1111) - (if (andmap - (lambda (g1113) - (if (eq? (car g1113) - 'ref) - (memq (cadr g1113) - g1112) - '#f)) - (cdr g1110)) - (cons 'map - (cons (list 'primitive - (car g1110)) - (map ((lambda (g1114) - (lambda (g1115) - (cdr (assq (cadr g1115) - g1114)))) - (map cons - g1112 - g1111)) - (cdr g1110)))) - (cons 'map - (cons (list 'lambda - g1112 - g1110) - g1111))))) - (map cdr g1109) - (map (lambda (g1116) - (list 'ref (car g1116))) - g1109)))) - (g1031 (lambda (g1042 g1041) - (list 'apply - '(primitive append) - (g1032 g1042 g1041)))) - (g1030 (lambda (g1104 g1101 g1103 g1102) - (if (g41 g1103 '0) - (values g1101 g1102) - (if (null? g1102) - (syntax-error - g1104 - '"missing ellipsis in syntax form") - (call-with-values - (lambda () - (g1030 - g1104 - g1101 - (g40 g1103 '1) - (cdr g1102))) - (lambda (g1106 g1105) - ((lambda (g1107) - (if g1107 - (values - (cdr g1107) - g1102) - ((lambda (g1108) - (values - g1108 - (cons (cons (cons g1106 - g1108) - (car g1102)) - g1105))) - (g114 'tmp)))) - (assq g1106 - (car g1102))))))))) - (g1029 (lambda (g1047 - g1043 - g1046 - g1044 - g1045) - (if (g66 g1043) - ((lambda (g1048) - ((lambda (g1049) - (if (eq? (g58 g1049) - 'syntax) - (call-with-values - (lambda () - ((lambda (g1052) - (g1030 - g1047 - (car g1052) - (cdr g1052) - g1044)) - (g59 g1049))) - (lambda (g1051 - g1050) - (values - (list 'ref - g1051) - g1050))) - (if (g1045 g1043) - (syntax-error - g1047 - '"misplaced ellipsis in syntax form") - (values - (list 'quote - g1043) - g1044)))) - (g63 g1048 g1046))) - (g88 g1043 '(()))) - ((lambda (g1053) - ((lambda (g1054) - (if (if g1054 - (apply - (lambda (g1056 - g1055) - (g1045 - g1056)) - g1054) - '#f) - (apply - (lambda (g1058 - g1057) - (g1029 - g1047 - g1057 - g1046 - g1044 - (lambda (g1059) - '#f))) - g1054) - ((lambda (g1060) - (if (if g1060 - (apply - (lambda (g1063 - g1061 - g1062) - (g1045 - g1061)) - g1060) - '#f) - (apply - (lambda (g1066 - g1064 - g1065) - ((letrec ((g1067 (lambda (g1069 - g1068) - ((lambda (g1070) - ((lambda (g1071) - (if (if g1071 - (apply - (lambda (g1073 - g1072) - (g1045 - g1073)) - g1071) - '#f) - (apply - (lambda (g1075 - g1074) - (g1067 - g1074 - (lambda (g1076) - (call-with-values - (lambda () - (g1068 - (cons '() - g1076))) - (lambda (g1078 - g1077) - (if (null? - (car g1077)) - (syntax-error - g1047 - '"extra ellipsis in syntax form") - (values - (g1031 - g1078 - (car g1077)) - (cdr g1077)))))))) - g1071) - ((lambda (g1079) - (call-with-values - (lambda () - (g1029 - g1047 - g1069 - g1046 - g1044 - g1045)) - (lambda (g1081 - g1080) - (call-with-values - (lambda () - (g1068 - g1080)) - (lambda (g1083 - g1082) - (values - (g1034 - g1083 - g1081) - g1082)))))) - g1070))) - (syntax-dispatch - g1070 - '(any . - any)))) - g1069)))) - g1067) - g1065 - (lambda (g1084) - (call-with-values - (lambda () - (g1029 - g1047 - g1066 - g1046 - (cons '() - g1084) - g1045)) - (lambda (g1086 - g1085) - (if (null? - (car g1085)) - (syntax-error - g1047 - '"extra ellipsis in syntax form") - (values - (g1032 - g1086 - (car g1085)) - (cdr g1085)))))))) - g1060) - ((lambda (g1087) - (if g1087 - (apply - (lambda (g1089 - g1088) - (call-with-values - (lambda () - (g1029 - g1047 - g1089 - g1046 - g1044 - g1045)) - (lambda (g1091 - g1090) - (call-with-values - (lambda () - (g1029 - g1047 - g1088 - g1046 - g1090 - g1045)) - (lambda (g1093 - g1092) - (values - (g1033 - g1091 - g1093) - g1092)))))) - g1087) - ((lambda (g1094) - (if g1094 - (apply - (lambda (g1096 - g1095) - (call-with-values - (lambda () - (g1029 - g1047 - (cons g1096 - g1095) - g1046 - g1044 - g1045)) - (lambda (g1098 - g1097) - (values - (g1035 - g1098) - g1097)))) - g1094) - ((lambda (g1100) - (values - (list 'quote - g1043) - g1044)) - g1053))) - (syntax-dispatch - g1053 - '#(vector - (any . - each-any)))))) - (syntax-dispatch - g1053 - '(any . - any))))) - (syntax-dispatch - g1053 - '(any any - . - any))))) - (syntax-dispatch - g1053 - '(any any)))) - g1043))))) - (lambda (g1125 g1122 g1124 g1123) - ((lambda (g1126) - ((lambda (g1127) - ((lambda (g1128) - (if g1128 - (apply - (lambda (g1130 g1129) - (call-with-values - (lambda () - (g1029 - g1126 - g1129 - g1122 - '() - g111)) - (lambda (g1132 g1131) - (g1036 g1132)))) - g1128) - ((lambda (g1133) - (syntax-error g1126)) - g1127))) - (syntax-dispatch g1127 '(any any)))) - g1126)) - (g95 g1125 g1124 g1123))))))) - (g64 'core - 'lambda - (lambda (g817 g814 g816 g815) - ((lambda (g818) - ((lambda (g819) - (if g819 - (apply - (lambda (g821 g820) - (g107 (g95 g817 g816 g815) - g820 - g814 - g816 - (lambda (g823 g822) - (list 'lambda g823 g822)))) - g819) - (syntax-error g818))) - (syntax-dispatch g818 '(any . any)))) - g817))) - (g64 'core - 'letrec - (lambda (g1011 g1008 g1010 g1009) - ((lambda (g1012) - ((lambda (g1013) - (if g1013 - (apply - (lambda (g1018 g1014 g1017 g1015 g1016) - ((lambda (g1019) - (if (not (g91 g1019)) - (syntax-error - g1011 - '"duplicate bound variable in") - ((lambda (g1021 g1020) - ((lambda (g1023 g1022) - (g50 g1009 - g1020 - (map (lambda (g1026) - (g102 g1026 - g1022 - g1023)) - g1017) - (g106 (cons g1015 - g1016) - (g95 g1011 - g1023 - g1009) - g1022 - g1023))) - (g83 g1019 g1021 g1010) - (g61 g1021 g1020 g1008))) - (g72 g1019) - (map g114 g1019)))) - g1014)) - g1013) - ((lambda (g1028) - (syntax-error (g95 g1011 g1010 g1009))) - g1012))) - (syntax-dispatch - g1012 - '(any #(each (any any)) any . each-any)))) - g1011))) - (g64 'core - 'if - (lambda (g827 g824 g826 g825) - ((lambda (g828) - ((lambda (g829) - (if g829 - (apply - (lambda (g832 g830 g831) - (list 'if - (g102 g830 g824 g826) - (g102 g831 g824 g826) - (g110))) - g829) - ((lambda (g833) - (if g833 - (apply - (lambda (g837 g834 g836 g835) - (list 'if - (g102 g834 g824 g826) - (g102 g836 g824 g826) - (g102 g835 g824 g826))) - g833) - ((lambda (g838) - (syntax-error - (g95 g827 g826 g825))) - g828))) - (syntax-dispatch - g828 - '(any any any any))))) - (syntax-dispatch g828 '(any any any)))) - g827))) - (g64 'core - 'set! - (lambda (g994 g991 g993 g992) - ((lambda (g995) - ((lambda (g996) - (if (if g996 - (apply - (lambda (g999 g997 g998) (g66 g997)) - g996) - '#f) - (apply - (lambda (g1002 g1000 g1001) - ((lambda (g1004 g1003) - ((lambda (g1005) - ((lambda (g1006) - (if (memv g1006 '(lexical)) - (list 'set! - (g59 g1005) - g1004) - (if (memv g1006 '(global)) - (list 'set! - g1003 - g1004) - (if (memv g1006 - '(displaced-lexical)) - (syntax-error - (g94 g1000 g993) - '"identifier out of context") - (syntax-error - (g95 g994 - g993 - g992)))))) - (g58 g1005))) - (g63 g1003 g991))) - (g102 g1001 g991 g993) - (g88 g1000 g993))) - g996) - ((lambda (g1007) - (syntax-error (g95 g994 g993 g992))) - g995))) - (syntax-dispatch g995 '(any any any)))) - g994))) - (g64 'begin 'begin '()) - (g64 'define 'define '()) - (g64 'define-syntax 'define-syntax '()) - (g64 'eval-when 'eval-when '()) - (g64 'core - 'syntax-case - ((lambda () - (letrec ((g842 (lambda (g899 g896 g898 g897) - (if (null? g898) - (list 'syntax-error g899) - ((lambda (g900) - ((lambda (g901) - (if g901 - (apply - (lambda (g903 g902) - (if (if (g66 g903) - (andmap - (lambda (g904) - (not (g89 g903 - g904))) - (cons '#(syntax-object - ... - ((top) - #(ribcage - #(pat - exp) - #((top) - (top)) - #("i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x - keys - clauses - r) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")) - #(ribcage - (gen-syntax-case - gen-clause - build-dispatch-call - convert-pattern) - ((top) - (top) - (top) - (top)) - ("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 - self-evaluating? - build-lexical-var - build-letrec - 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)) - ("i" "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "i" - "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")) - #(ribcage - (define-structure) - ((top)) - ("i")))) - g896)) - '#f) - ((lambda (g906 - g905) - (list (list 'lambda - (list g905) - (g102 g902 - (g60 g906 - (list (cons 'syntax - (cons g905 - '0))) - g897) - (g83 (list g903) - g906 - '(())))) - g899)) - (list (g71)) - (g114 g903)) - (g841 g899 - g896 - (cdr g898) - g897 - g903 - '#t - g902))) - g901) - ((lambda (g907) - (if g907 - (apply - (lambda (g910 - g908 - g909) - (g841 g899 - g896 - (cdr g898) - g897 - g910 - g908 - g909)) - g907) - ((lambda (g911) - (syntax-error - (car g898) - '"invalid syntax-case clause")) - g900))) - (syntax-dispatch - g900 - '(any any any))))) - (syntax-dispatch - g900 - '(any any)))) - (car g898))))) - (g841 (lambda (g849 - g843 - g848 - g844 - g847 - g845 - g846) - (call-with-values - (lambda () (g839 g847 g843)) - (lambda (g851 g850) - (if (not (g92 (map car g850))) - (syntax-error - g847 - '"duplicate pattern variable in syntax-case pattern") - (if (not (andmap - (lambda (g852) - (not (g111 (car g852)))) - g850)) - (syntax-error - g847 - '"misplaced ellipsis in syntax-case pattern") - ((lambda (g853) - (list (list 'lambda - (list g853) - ((lambda (g854) - (list 'if - ((lambda (g855) - ((lambda (g856) - (if g856 - (apply - (lambda () - g854) - g856) - ((lambda (g857) - (list 'if - g854 - (g840 g850 - g845 - g854 - g844) - (list 'quote - '#f))) - g855))) - (syntax-dispatch - g855 - '#(atom - #t)))) - g845) - (g840 g850 - g846 - g854 - g844) - (g842 g849 - g843 - g848 - g844))) - g853)) - (if (eq? g851 - 'any) - (list 'list - g849) - (list 'syntax-dispatch - g849 - (list 'quote - g851))))) - (g114 'tmp)))))))) - (g840 (lambda (g889 g886 g888 g887) - ((lambda (g891 g890) - ((lambda (g893 g892) - (list 'apply - (list 'lambda - g892 - (g102 g886 - (g60 g893 - (map (lambda (g895 - g894) - (cons 'syntax - (cons g895 - g894))) - g892 - (map cdr - g889)) - g887) - (g83 g891 - g893 - '(())))) - g888)) - (g72 g891) - (map g114 g891))) - (map car g889) - (map cdr g889)))) - (g839 (lambda (g859 g858) - ((letrec ((g860 (lambda (g863 - g861 - g862) - (if (g66 g863) - (if (g93 g863 - g858) - (values - (vector - 'free-id - g863) - g862) - (values - 'any - (cons (cons g863 - g861) - g862))) - ((lambda (g864) - ((lambda (g865) - (if (if g865 - (apply - (lambda (g867 - g866) - (g111 g866)) - g865) - '#f) - (apply - (lambda (g869 - g868) - (call-with-values - (lambda () - (g860 g869 - (g39 g861 - '1) - g862)) - (lambda (g871 - g870) - (values - (if (eq? g871 - 'any) - 'each-any - (vector - 'each - g871)) - g870)))) - g865) - ((lambda (g872) - (if g872 - (apply - (lambda (g874 - g873) - (call-with-values - (lambda () - (g860 g873 - g861 - g862)) - (lambda (g876 - g875) - (call-with-values - (lambda () - (g860 g874 - g861 - g875)) - (lambda (g878 - g877) - (values - (cons g878 - g876) - g877)))))) - g872) - ((lambda (g879) - (if g879 - (apply - (lambda () - (values - '() - g862)) - g879) - ((lambda (g880) - (if g880 - (apply - (lambda (g881) - (call-with-values - (lambda () - (g860 g881 - g861 - g862)) - (lambda (g883 - g882) - (values - (vector - 'vector - g883) - g882)))) - g880) - ((lambda (g885) - (values - (vector - 'atom - (g113 g863 - '(()))) - g862)) - g864))) - (syntax-dispatch - g864 - '#(vector - each-any))))) - (syntax-dispatch - g864 - '())))) - (syntax-dispatch - g864 - '(any . - any))))) - (syntax-dispatch - g864 - '(any any)))) - g863))))) - g860) - g859 - '0 - '())))) - (lambda (g915 g912 g914 g913) - ((lambda (g916) - ((lambda (g917) - ((lambda (g918) - (if g918 - (apply - (lambda (g922 g919 g921 g920) - (if (andmap - (lambda (g924) - (if (g66 g924) - (not (g111 g924)) - '#f)) - g921) - ((lambda (g925) - (list (list 'lambda - (list g925) - (g842 g925 - g921 - g920 - g912)) - (g102 g919 - g912 - '(())))) - (g114 'tmp)) - (syntax-error - g916 - '"invalid literals list in"))) - g918) - (syntax-error g917))) - (syntax-dispatch - g917 - '(any any each-any . each-any)))) - g916)) - (g95 g915 g914 g913))))))) - (set! sc-expand - ((lambda (g989 g988) - (lambda (g990) - (if (if (pair? g990) (equal? (car g990) g38) '#f) - (cadr g990) - (g101 g990 '() '((top)) g989 g988)))) - 'e - '(eval))) - (set! identifier? (lambda (g928) (g65 g928))) - (set! datum->syntax-object - (lambda (g986 g985) - (begin ((lambda (g987) - (if (not (g65 g987)) - (g46 'datum->syntax-object - '"invalid argument" - g987) - (void))) - g986) - (g51 g985 (g54 g986))))) - (set! syntax-object->datum - (lambda (g929) (g113 g929 '(())))) - (set! generate-temporaries - (lambda (g982) - (begin ((lambda (g984) - (if (not (list? g984)) - (g46 'generate-temporaries - '"invalid argument" - g984) - (void))) - g982) - (map (lambda (g983) (g94 (gensym) '((top)))) - g982)))) - (set! free-identifier=? - (lambda (g931 g930) - (begin ((lambda (g933) - (if (not (g65 g933)) - (g46 'free-identifier=? - '"invalid argument" - g933) - (void))) - g931) - ((lambda (g932) - (if (not (g65 g932)) - (g46 'free-identifier=? - '"invalid argument" - g932) - (void))) - g930) - (g89 g931 g930)))) - (set! bound-identifier=? - (lambda (g979 g978) - (begin ((lambda (g981) - (if (not (g65 g981)) - (g46 'bound-identifier=? - '"invalid argument" - g981) - (void))) - g979) - ((lambda (g980) - (if (not (g65 g980)) - (g46 'bound-identifier=? - '"invalid argument" - g980) - (void))) - g978) - (g90 g979 g978)))) - (set! syntax-error - (lambda (g934 . g935) - (begin (for-each - (lambda (g937) - ((lambda (g938) - (if (not (string? g938)) - (g46 'syntax-error - '"invalid argument" - g938) - (void))) - g937)) - g935) - ((lambda (g936) (g46 '#f g936 (g113 g934 '(())))) - (if (null? g935) - '"invalid syntax" - (apply string-append g935)))))) - (set! install-global-transformer - (lambda (g975 g974) - (begin ((lambda (g977) - (if (not (symbol? g977)) - (g46 'define-syntax - '"invalid argument" - g977) - (void))) - g975) - ((lambda (g976) - (if (not (procedure? g976)) - (g46 'define-syntax - '"invalid argument" - g976) - (void))) - g974) - (g64 'macro g975 g974)))) - ((lambda () - (letrec ((g943 (lambda (g967 g964 g966 g965) - (if (not g965) - '#f - (if (eq? g964 'any) - (cons (g94 g967 g966) g965) - (if (g52 g967) - (g942 ((lambda (g968) - (if (g43 g968) - (annotation-expression - g968) - g968)) - (g53 g967)) - g964 - (g85 g966 (g54 g967)) - g965) - (g942 ((lambda (g969) - (if (g43 g969) - (annotation-expression - g969) - g969)) - g967) - g964 - g966 - g965)))))) - (g942 (lambda (g947 g944 g946 g945) - (if (null? g944) - (if (null? g947) g945 '#f) - (if (pair? g944) - (if (pair? g947) - (g943 (car g947) - (car g944) - g946 - (g943 (cdr g947) - (cdr g944) - g946 - g945)) - '#f) - (if (eq? g944 'each-any) - ((lambda (g948) - (if g948 - (cons g948 g945) - '#f)) - (g940 g947 g946)) - ((lambda (g949) - (if (memv g949 '(each)) - (if (null? g947) - (g941 (vector-ref - g944 - '1) - g945) - ((lambda (g950) - (if g950 - ((letrec ((g951 (lambda (g952) - (if (null? - (car g952)) - g945 - (cons (map car - g952) - (g951 (map cdr - g952))))))) - g951) - g950) - '#f)) - (g939 g947 - (vector-ref - g944 - '1) - g946))) - (if (memv g949 - '(free-id)) - (if (g66 g947) - (if (g89 (g94 g947 - g946) - (vector-ref - g944 - '1)) - g945 - '#f) - '#f) - (if (memv g949 - '(atom)) - (if (equal? - (vector-ref - g944 - '1) - (g113 g947 - g946)) - g945 - '#f) - (if (memv g949 - '(vector)) - (if (vector? - g947) - (g943 (vector->list - g947) - (vector-ref - g944 - '1) - g946 - g945) - '#f) - (void)))))) - (vector-ref g944 '0))))))) - (g941 (lambda (g962 g961) - (if (null? g962) - g961 - (if (eq? g962 'any) - (cons '() g961) - (if (pair? g962) - (g941 (car g962) - (g941 (cdr g962) - g961)) - (if (eq? g962 'each-any) - (cons '() g961) - ((lambda (g963) - (if (memv g963 - '(each)) - (g941 (vector-ref - g962 - '1) - g961) - (if (memv g963 - '(free-id - atom)) - g961 - (if (memv g963 - '(vector)) - (g941 (vector-ref - g962 - '1) - g961) - (void))))) - (vector-ref - g962 - '0)))))))) - (g940 (lambda (g954 g953) - (if (g43 g954) - (g940 (annotation-expression g954) - g953) - (if (pair? g954) - ((lambda (g955) - (if g955 - (cons (g94 (car g954) - g953) - g955) - '#f)) - (g940 (cdr g954) g953)) - (if (null? g954) - '() - (if (g52 g954) - (g940 (g53 g954) - (g85 g953 - (g54 g954))) - '#f)))))) - (g939 (lambda (g958 g956 g957) - (if (g43 g958) - (g939 (annotation-expression g958) - g956 - g957) - (if (pair? g958) - ((lambda (g959) - (if g959 - ((lambda (g960) - (if g960 - (cons g959 g960) - '#f)) - (g939 (cdr g958) - g956 - g957)) - '#f)) - (g943 (car g958) - g956 - g957 - '())) - (if (null? g958) - '() - (if (g52 g958) - (g939 (g53 g958) - g956 - (g85 g957 - (g54 g958))) - '#f))))))) - (set! syntax-dispatch - (lambda (g971 g970) - (if (eq? g970 'any) - (list g971) - (if (g52 g971) - (g942 ((lambda (g972) - (if (g43 g972) - (annotation-expression g972) - g972)) - (g53 g971)) - g970 - (g54 g971) - '()) - (g942 ((lambda (g973) - (if (g43 g973) - (annotation-expression g973) - g973)) - g971) - g970 - '(()) - '())))))))))))))) (install-global-transformer 'with-syntax - (lambda (g1163) - ((lambda (g1164) - ((lambda (g1165) - (if g1165 - (apply - (lambda (g1168 g1166 g1167) - (cons '#(syntax-object - begin - ((top) - #(ribcage - #(_ e1 e2) - #((top) (top) (top)) - #("i" "i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")))) - (cons g1166 g1167))) - g1165) - ((lambda (g1170) - (if g1170 - (apply - (lambda (g1175 g1171 g1174 g1172 g1173) - (list '#(syntax-object - syntax-case - ((top) - #(ribcage - #(_ out in e1 e2) - #((top) (top) (top) (top) (top)) - #("i" "i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")))) - g1174 - '() - (list g1171 - (cons '#(syntax-object - begin - ((top) - #(ribcage - #(_ out in e1 e2) - #((top) - (top) - (top) - (top) - (top)) - #("i" "i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons g1172 g1173))))) - g1170) - ((lambda (g1177) - (if g1177 - (apply - (lambda (g1182 g1178 g1181 g1179 g1180) - (list '#(syntax-object - syntax-case - ((top) - #(ribcage - #(_ out in e1 e2) - #((top) - (top) - (top) - (top) - (top)) - #("i" "i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")))) - (cons '#(syntax-object - list - ((top) - #(ribcage - #(_ out in e1 e2) - #((top) - (top) - (top) - (top) - (top)) - #("i" "i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))) - g1181) - '() - (list g1178 - (cons '#(syntax-object - begin - ((top) - #(ribcage - #(_ out in e1 e2) - #((top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons g1179 g1180))))) - g1177) - (syntax-error g1164))) - (syntax-dispatch - g1164 - '(any #(each (any any)) any . each-any))))) - (syntax-dispatch g1164 '(any ((any any)) any . each-any))))) - (syntax-dispatch g1164 '(any () any . each-any)))) - g1163))) + (lambda (syntmp-x-1462) + ((lambda (syntmp-tmp-1463) + ((lambda (syntmp-tmp-1464) + (if syntmp-tmp-1464 + (apply (lambda (syntmp-_-1465 syntmp-e1-1466 syntmp-e2-1467) + (cons '#(syntax-object + let + ((top) + #(ribcage + #(_ e1 e2) + #((top) (top) (top)) + #("i" "i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")))) + (cons '() + (cons syntmp-e1-1466 syntmp-e2-1467)))) + syntmp-tmp-1464) + ((lambda (syntmp-tmp-1469) + (if syntmp-tmp-1469 + (apply (lambda (syntmp-_-1470 + syntmp-out-1471 + syntmp-in-1472 + syntmp-e1-1473 + syntmp-e2-1474) + (list '#(syntax-object + syntax-case + ((top) + #(ribcage + #(_ out in e1 e2) + #((top) (top) (top) (top) (top)) + #("i" "i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")))) + syntmp-in-1472 + '() + (list syntmp-out-1471 + (cons '#(syntax-object + let + ((top) + #(ribcage + #(_ out in e1 e2) + #((top) + (top) + (top) + (top) + (top)) + #("i" "i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i")))) + (cons '() + (cons syntmp-e1-1473 + syntmp-e2-1474)))))) + syntmp-tmp-1469) + ((lambda (syntmp-tmp-1476) + (if syntmp-tmp-1476 + (apply (lambda (syntmp-_-1477 + syntmp-out-1478 + syntmp-in-1479 + syntmp-e1-1480 + syntmp-e2-1481) + (list '#(syntax-object + syntax-case + ((top) + #(ribcage + #(_ out in e1 e2) + #((top) (top) (top) (top) (top)) + #("i" "i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")))) + (cons '#(syntax-object + list + ((top) + #(ribcage + #(_ out in e1 e2) + #((top) + (top) + (top) + (top) + (top)) + #("i" "i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i")))) + syntmp-in-1479) + '() + (list syntmp-out-1478 + (cons '#(syntax-object + let + ((top) + #(ribcage + #(_ out in e1 e2) + #((top) + (top) + (top) + (top) + (top)) + #("i" "i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i")))) + (cons '() + (cons syntmp-e1-1480 + syntmp-e2-1481)))))) + syntmp-tmp-1476) + (syntax-error syntmp-tmp-1463))) + (syntax-dispatch + syntmp-tmp-1463 + '(any #(each (any any)) any . each-any))))) + (syntax-dispatch + syntmp-tmp-1463 + '(any ((any any)) any . each-any))))) + (syntax-dispatch + syntmp-tmp-1463 + '(any () any . each-any)))) + syntmp-x-1462))) + (install-global-transformer 'syntax-rules - (lambda (g1186) - ((lambda (g1187) - ((lambda (g1188) - (if g1188 - (apply - (lambda (g1193 g1189 g1192 g1190 g1191) - (list '#(syntax-object - lambda - ((top) - #(ribcage - #(_ k keyword pattern template) - #((top) (top) (top) (top) (top)) - #("i" "i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")))) - '(#(syntax-object - x - ((top) - #(ribcage - #(_ k keyword pattern template) - #((top) (top) (top) (top) (top)) - #("i" "i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i"))))) - (cons '#(syntax-object - syntax-case - ((top) - #(ribcage - #(_ k keyword pattern template) - #((top) (top) (top) (top) (top)) - #("i" "i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")))) - (cons '#(syntax-object - x - ((top) - #(ribcage - #(_ k keyword pattern template) - #((top) (top) (top) (top) (top)) - #("i" "i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")))) - (cons g1189 - (map (lambda (g1196 g1195) - (list (cons '#(syntax-object - dummy - ((top) - #(ribcage - #(_ - k - keyword - pattern - template) - #((top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - g1195) - (list '#(syntax-object - syntax - ((top) - #(ribcage - #(_ - k - keyword - pattern - template) - #((top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - g1196))) - g1191 - g1190)))))) - g1188) - (syntax-error g1187))) - (syntax-dispatch - g1187 - '(any each-any . #(each ((any . any) any)))))) - g1186))) + (lambda (syntmp-xx-1503) + (letrec ((syntmp-expand-syntax-rules-1504 + (lambda (syntmp-dots-1505 + syntmp-keys-1506 + syntmp-docstrings-1507 + syntmp-clauses-1508) + ((lambda (syntmp-tmp-1509) + ((lambda (syntmp-tmp-1510) + (if syntmp-tmp-1510 + (apply (lambda (syntmp-k-1511 + syntmp-docstring-1512 + syntmp-keyword-1513 + syntmp-pattern-1514 + syntmp-template-1515) + ((lambda (syntmp-tmp-1516) + ((lambda (syntmp-form-1517) + (if syntmp-dots-1505 + ((lambda (syntmp-tmp-1518) + ((lambda (syntmp-dots-1519) + (list '#(syntax-object + with-ellipsis + ((top) + #(ribcage () () ()) + #(ribcage + #(dots) + #((top)) + #("i")) + #(ribcage () () ()) + #(ribcage + #(form) + #((top)) + #("i")) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage + #(k + docstring + keyword + pattern + template) + #((top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i")) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage + #(dots + keys + docstrings + clauses) + #((top) + (top) + (top) + (top)) + #("i" "i" "i" "i")) + #(ribcage + (expand-syntax-rules) + ((top)) + ("i")) + #(ribcage + #(xx) + #((top)) + #("i")))) + syntmp-dots-1519 + syntmp-form-1517)) + syntmp-tmp-1518)) + syntmp-dots-1505) + syntmp-form-1517)) + syntmp-tmp-1516)) + (cons '#(syntax-object + lambda + ((top) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage + #(k + docstring + keyword + pattern + template) + #((top) (top) (top) (top) (top)) + #("i" "i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage + #(dots keys docstrings clauses) + #((top) (top) (top) (top)) + #("i" "i" "i" "i")) + #(ribcage + (expand-syntax-rules) + ((top)) + ("i")) + #(ribcage #(xx) #((top)) #("i")))) + (cons '(#(syntax-object + x + ((top) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage + #(k + docstring + keyword + pattern + template) + #((top) + (top) + (top) + (top) + (top)) + #("i" "i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage + #(dots + keys + docstrings + clauses) + #((top) + (top) + (top) + (top)) + #("i" "i" "i" "i")) + #(ribcage + (expand-syntax-rules) + ((top)) + ("i")) + #(ribcage + #(xx) + #((top)) + #("i"))))) + (append + syntmp-docstring-1512 + (list (cons '#(syntax-object + syntax-case + ((top) + #(ribcage + () + () + ()) + #(ribcage + () + () + ()) + #(ribcage + #(k + docstring + keyword + pattern + template) + #((top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + () + () + ()) + #(ribcage + #(dots + keys + docstrings + clauses) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")) + #(ribcage + (expand-syntax-rules) + ((top)) + ("i")) + #(ribcage + #(xx) + #((top)) + #("i")))) + (cons '#(syntax-object + x + ((top) + #(ribcage + () + () + ()) + #(ribcage + () + () + ()) + #(ribcage + #(k + docstring + keyword + pattern + template) + #((top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + () + () + ()) + #(ribcage + #(dots + keys + docstrings + clauses) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")) + #(ribcage + (expand-syntax-rules) + ((top)) + ("i")) + #(ribcage + #(xx) + #((top)) + #("i")))) + (cons syntmp-k-1511 + (map (lambda (syntmp-tmp-1522 + syntmp-tmp-1521) + (list (cons '#(syntax-object + dummy + ((top) + #(ribcage + () + () + ()) + #(ribcage + () + () + ()) + #(ribcage + #(k + docstring + keyword + pattern + template) + #((top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + () + () + ()) + #(ribcage + #(dots + keys + docstrings + clauses) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")) + #(ribcage + (expand-syntax-rules) + ((top)) + ("i")) + #(ribcage + #(xx) + #((top)) + #("i")))) + syntmp-tmp-1521) + (list '#(syntax-object + syntax + ((top) + #(ribcage + () + () + ()) + #(ribcage + () + () + ()) + #(ribcage + #(k + docstring + keyword + pattern + template) + #((top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + () + () + ()) + #(ribcage + #(dots + keys + docstrings + clauses) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")) + #(ribcage + (expand-syntax-rules) + ((top)) + ("i")) + #(ribcage + #(xx) + #((top)) + #("i")))) + syntmp-tmp-1522))) + syntmp-template-1515 + syntmp-pattern-1514)))))))))) + syntmp-tmp-1510) + (syntax-error syntmp-tmp-1509))) + (syntax-dispatch + syntmp-tmp-1509 + '(each-any each-any #(each ((any . any) any)))))) + (list syntmp-keys-1506 + syntmp-docstrings-1507 + syntmp-clauses-1508))))) + ((lambda (syntmp-tmp-1524) + ((lambda (syntmp-tmp-1525) + (if syntmp-tmp-1525 + (apply (lambda (syntmp-_-1526 + syntmp-k-1527 + syntmp-keyword-1528 + syntmp-pattern-1529 + syntmp-template-1530) + (syntmp-expand-syntax-rules-1504 + #f + syntmp-k-1527 + '() + (map (lambda (syntmp-tmp-1534 + syntmp-tmp-1533 + syntmp-tmp-1532) + (list (cons syntmp-tmp-1532 syntmp-tmp-1533) + syntmp-tmp-1534)) + syntmp-template-1530 + syntmp-pattern-1529 + syntmp-keyword-1528))) + syntmp-tmp-1525) + ((lambda (syntmp-tmp-1535) + (if (if syntmp-tmp-1535 + (apply (lambda (syntmp-_-1536 + syntmp-k-1537 + syntmp-docstring-1538 + syntmp-keyword-1539 + syntmp-pattern-1540 + syntmp-template-1541) + (string? + (syntax-object->datum + syntmp-docstring-1538))) + syntmp-tmp-1535) + #f) + (apply (lambda (syntmp-_-1542 + syntmp-k-1543 + syntmp-docstring-1544 + syntmp-keyword-1545 + syntmp-pattern-1546 + syntmp-template-1547) + (syntmp-expand-syntax-rules-1504 + #f + syntmp-k-1543 + (list syntmp-docstring-1544) + (map (lambda (syntmp-tmp-1551 + syntmp-tmp-1550 + syntmp-tmp-1549) + (list (cons syntmp-tmp-1549 + syntmp-tmp-1550) + syntmp-tmp-1551)) + syntmp-template-1547 + syntmp-pattern-1546 + syntmp-keyword-1545))) + syntmp-tmp-1535) + ((lambda (syntmp-tmp-1552) + (if (if syntmp-tmp-1552 + (apply (lambda (syntmp-_-1553 + syntmp-dots-1554 + syntmp-k-1555 + syntmp-keyword-1556 + syntmp-pattern-1557 + syntmp-template-1558) + (identifier? syntmp-dots-1554)) + syntmp-tmp-1552) + #f) + (apply (lambda (syntmp-_-1559 + syntmp-dots-1560 + syntmp-k-1561 + syntmp-keyword-1562 + syntmp-pattern-1563 + syntmp-template-1564) + (syntmp-expand-syntax-rules-1504 + syntmp-dots-1560 + syntmp-k-1561 + '() + (map (lambda (syntmp-tmp-1568 + syntmp-tmp-1567 + syntmp-tmp-1566) + (list (cons syntmp-tmp-1566 + syntmp-tmp-1567) + syntmp-tmp-1568)) + syntmp-template-1564 + syntmp-pattern-1563 + syntmp-keyword-1562))) + syntmp-tmp-1552) + ((lambda (syntmp-tmp-1569) + (if (if syntmp-tmp-1569 + (apply (lambda (syntmp-_-1570 + syntmp-dots-1571 + syntmp-k-1572 + syntmp-docstring-1573 + syntmp-keyword-1574 + syntmp-pattern-1575 + syntmp-template-1576) + (and (identifier? syntmp-dots-1571) + (string? + (syntax-object->datum + syntmp-docstring-1573)))) + syntmp-tmp-1569) + #f) + (apply (lambda (syntmp-_-1577 + syntmp-dots-1578 + syntmp-k-1579 + syntmp-docstring-1580 + syntmp-keyword-1581 + syntmp-pattern-1582 + syntmp-template-1583) + (syntmp-expand-syntax-rules-1504 + syntmp-dots-1578 + syntmp-k-1579 + (list syntmp-docstring-1580) + (map (lambda (syntmp-tmp-1587 + syntmp-tmp-1586 + syntmp-tmp-1585) + (list (cons syntmp-tmp-1585 + syntmp-tmp-1586) + syntmp-tmp-1587)) + syntmp-template-1583 + syntmp-pattern-1582 + syntmp-keyword-1581))) + syntmp-tmp-1569) + (syntax-error syntmp-tmp-1524))) + (syntax-dispatch + syntmp-tmp-1524 + '(any any + each-any + any + . + #(each ((any . any) any))))))) + (syntax-dispatch + syntmp-tmp-1524 + '(any any each-any . #(each ((any . any) any))))))) + (syntax-dispatch + syntmp-tmp-1524 + '(any each-any any . #(each ((any . any) any))))))) + (syntax-dispatch + syntmp-tmp-1524 + '(any each-any . #(each ((any . any) any)))))) + syntmp-xx-1503)))) + (install-global-transformer - 'or - (lambda (g1197) - ((lambda (g1198) - ((lambda (g1199) - (if g1199 - (apply - (lambda (g1200) - '#(syntax-object - #f - ((top) - #(ribcage #(_) #((top)) #("i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i"))))) - g1199) - ((lambda (g1201) - (if g1201 - (apply (lambda (g1203 g1202) g1202) g1201) - ((lambda (g1204) - (if g1204 - (apply - (lambda (g1208 g1205 g1207 g1206) - (list '#(syntax-object - let - ((top) - #(ribcage - #(_ e1 e2 e3) - #((top) (top) (top) (top)) - #("i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")))) - (list (list '#(syntax-object - t - ((top) - #(ribcage - #(_ e1 e2 e3) - #((top) - (top) - (top) - (top)) - #("i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))) - g1205)) - (list '#(syntax-object - if - ((top) - #(ribcage - #(_ e1 e2 e3) - #((top) - (top) - (top) - (top)) - #("i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))) - '#(syntax-object - t - ((top) - #(ribcage - #(_ e1 e2 e3) - #((top) - (top) - (top) - (top)) - #("i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))) - '#(syntax-object - t - ((top) - #(ribcage - #(_ e1 e2 e3) - #((top) - (top) - (top) - (top)) - #("i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons '#(syntax-object - or - ((top) - #(ribcage - #(_ e1 e2 e3) - #((top) - (top) - (top) - (top)) - #("i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons g1207 g1206))))) - g1204) - (syntax-error g1198))) - (syntax-dispatch g1198 '(any any any . each-any))))) - (syntax-dispatch g1198 '(any any))))) - (syntax-dispatch g1198 '(any)))) - g1197))) -(install-global-transformer - 'and - (lambda (g1210) - ((lambda (g1211) - ((lambda (g1212) - (if g1212 - (apply - (lambda (g1216 g1213 g1215 g1214) - (cons '#(syntax-object - if - ((top) - #(ribcage - #(_ e1 e2 e3) - #((top) (top) (top) (top)) - #("i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")))) - (cons g1213 - (cons (cons '#(syntax-object - and - ((top) - #(ribcage - #(_ e1 e2 e3) - #((top) (top) (top) (top)) - #("i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons g1215 g1214)) - '(#(syntax-object - #f - ((top) - #(ribcage - #(_ e1 e2 e3) - #((top) (top) (top) (top)) - #("i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i"))))))))) - g1212) - ((lambda (g1218) - (if g1218 - (apply (lambda (g1220 g1219) g1219) g1218) - ((lambda (g1221) - (if g1221 - (apply - (lambda (g1222) - '#(syntax-object - #t - ((top) - #(ribcage #(_) #((top)) #("i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i"))))) - g1221) - (syntax-error g1211))) - (syntax-dispatch g1211 '(any))))) - (syntax-dispatch g1211 '(any any))))) - (syntax-dispatch g1211 '(any any any . each-any)))) - g1210))) -(install-global-transformer - 'let - (lambda (g1223) - ((lambda (g1224) - ((lambda (g1225) - (if (if g1225 - (apply - (lambda (g1230 g1226 g1229 g1227 g1228) - (andmap identifier? g1226)) - g1225) - '#f) - (apply - (lambda (g1236 g1232 g1235 g1233 g1234) - (cons (cons '#(syntax-object - lambda - ((top) - #(ribcage - #(_ x v e1 e2) - #((top) (top) (top) (top) (top)) - #("i" "i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")))) - (cons g1232 (cons g1233 g1234))) - g1235)) - g1225) - ((lambda (g1240) - (if (if g1240 - (apply - (lambda (g1246 g1241 g1245 g1242 g1244 g1243) - (andmap identifier? (cons g1241 g1245))) - g1240) - '#f) - (apply - (lambda (g1253 g1248 g1252 g1249 g1251 g1250) - (cons (list '#(syntax-object - letrec - ((top) - #(ribcage - #(_ f x v e1 e2) - #((top) - (top) - (top) - (top) - (top) - (top)) - #("i" "i" "i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")))) - (list (list g1248 - (cons '#(syntax-object - lambda - ((top) - #(ribcage - #(_ - f - x - v - e1 - e2) - #((top) - (top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons g1252 - (cons g1251 - g1250))))) - g1248) - g1249)) - g1240) - (syntax-error g1224))) - (syntax-dispatch - g1224 - '(any any #(each (any any)) any . each-any))))) - (syntax-dispatch - g1224 - '(any #(each (any any)) any . each-any)))) - g1223))) + 'define-syntax-rule + (lambda (syntmp-x-1667) + ((lambda (syntmp-tmp-1668) + ((lambda (syntmp-tmp-1669) + (if syntmp-tmp-1669 + (apply (lambda (syntmp-_-1670 + syntmp-name-1671 + syntmp-pattern-1672 + syntmp-template-1673) + (list '#(syntax-object + define-syntax + ((top) + #(ribcage + #(_ name pattern template) + #((top) (top) (top) (top)) + #("i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")))) + syntmp-name-1671 + (list '#(syntax-object + syntax-rules + ((top) + #(ribcage + #(_ name pattern template) + #((top) (top) (top) (top)) + #("i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")))) + '() + (list (cons syntmp-_-1670 syntmp-pattern-1672) + syntmp-template-1673)))) + syntmp-tmp-1669) + ((lambda (syntmp-tmp-1674) + (if (if syntmp-tmp-1674 + (apply (lambda (syntmp-_-1675 + syntmp-name-1676 + syntmp-pattern-1677 + syntmp-docstring-1678 + syntmp-template-1679) + (string? + (syntax-object->datum syntmp-docstring-1678))) + syntmp-tmp-1674) + #f) + (apply (lambda (syntmp-_-1680 + syntmp-name-1681 + syntmp-pattern-1682 + syntmp-docstring-1683 + syntmp-template-1684) + (list '#(syntax-object + define-syntax + ((top) + #(ribcage + #(_ name pattern docstring template) + #((top) (top) (top) (top) (top)) + #("i" "i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")))) + syntmp-name-1681 + (list '#(syntax-object + syntax-rules + ((top) + #(ribcage + #(_ + name + pattern + docstring + template) + #((top) (top) (top) (top) (top)) + #("i" "i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")))) + '() + syntmp-docstring-1683 + (list (cons syntmp-_-1680 + syntmp-pattern-1682) + syntmp-template-1684)))) + syntmp-tmp-1674) + (syntax-error syntmp-tmp-1668))) + (syntax-dispatch + syntmp-tmp-1668 + '(any (any . any) any any))))) + (syntax-dispatch + syntmp-tmp-1668 + '(any (any . any) any)))) + syntmp-x-1667))) + (install-global-transformer 'let* - (lambda (g1257) - ((lambda (g1258) - ((lambda (g1259) - (if (if g1259 - (apply - (lambda (g1264 g1260 g1263 g1261 g1262) - (andmap identifier? g1260)) - g1259) - '#f) - (apply - (lambda (g1270 g1266 g1269 g1267 g1268) - ((letrec ((g1271 (lambda (g1272) - (if (null? g1272) - (cons '#(syntax-object - let - ((top) - #(ribcage () () ()) - #(ribcage - #(bindings) - #((top)) - #("i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(let* x v e1 e2) - #((top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons '() - (cons g1267 g1268))) - ((lambda (g1274) - ((lambda (g1275) - (if g1275 - (apply - (lambda (g1277 g1276) - (list '#(syntax-object - let - ((top) - #(ribcage - #(body - binding) - #((top) - (top)) - #("i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(bindings) - #((top)) - #("i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(let* - x - v - e1 - e2) - #((top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (list g1276) - g1277)) - g1275) - (syntax-error g1274))) - (syntax-dispatch - g1274 - '(any any)))) - (list (g1271 (cdr g1272)) - (car g1272))))))) - g1271) - (map list g1266 g1269))) - g1259) - (syntax-error g1258))) - (syntax-dispatch - g1258 - '(any #(each (any any)) any . each-any)))) - g1257))) -(install-global-transformer - 'cond - (lambda (g1280) - ((lambda (g1281) - ((lambda (g1282) - (if g1282 - (apply - (lambda (g1285 g1283 g1284) - ((letrec ((g1286 (lambda (g1288 g1287) - (if (null? g1287) - ((lambda (g1289) - ((lambda (g1290) - (if g1290 - (apply - (lambda (g1292 g1291) - (cons '#(syntax-object - begin - ((top) - #(ribcage - #(e1 e2) - #((top) - (top)) - #("i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons g1292 - g1291))) - g1290) - ((lambda (g1294) - (if g1294 - (apply - (lambda (g1295) - (cons '#(syntax-object - let - ((top) - #(ribcage - #(e0) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons (list (list '#(syntax-object - t - ((top) - #(ribcage - #(e0) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - g1295)) - '((#(syntax-object - if - ((top) - #(ribcage - #(e0) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - #(syntax-object - t - ((top) - #(ribcage - #(e0) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - #(syntax-object - t - ((top) - #(ribcage - #(e0) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i"))))))))) - g1294) - ((lambda (g1296) - (if g1296 - (apply - (lambda (g1298 - g1297) - (list '#(syntax-object - let - ((top) - #(ribcage - #(e0 - e1) - #((top) - (top)) - #("i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (list (list '#(syntax-object - t - ((top) - #(ribcage - #(e0 - e1) - #((top) - (top)) - #("i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - g1298)) - (list '#(syntax-object - if - ((top) - #(ribcage - #(e0 - e1) - #((top) - (top)) - #("i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - '#(syntax-object - t - ((top) - #(ribcage - #(e0 - e1) - #((top) - (top)) - #("i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons g1297 - '(#(syntax-object - t - ((top) - #(ribcage - #(e0 - e1) - #((top) - (top)) - #("i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i"))))))))) - g1296) - ((lambda (g1299) - (if g1299 - (apply - (lambda (g1302 - g1300 - g1301) - (list '#(syntax-object - if - ((top) - #(ribcage - #(e0 - e1 - e2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - g1302 - (cons '#(syntax-object - begin - ((top) - #(ribcage - #(e0 - e1 - e2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons g1300 - g1301)))) - g1299) - ((lambda (g1304) - (syntax-error - g1280)) - g1289))) - (syntax-dispatch - g1289 - '(any any - . - each-any))))) - (syntax-dispatch - g1289 - '(any #(free-id - #(syntax-object - => - ((top) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i"))))) - any))))) - (syntax-dispatch - g1289 - '(any))))) - (syntax-dispatch - g1289 - '(#(free-id - #(syntax-object - else - ((top) - #(ribcage () () ()) - #(ribcage - #(clause clauses) - #((top) (top)) - #("i" "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ m1 m2) - #((top) - (top) - (top)) - #("i" "i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i"))))) - any - . - each-any)))) - g1288) - ((lambda (g1305) - ((lambda (g1306) - ((lambda (g1307) - ((lambda (g1308) - (if g1308 - (apply - (lambda (g1309) - (list '#(syntax-object - let - ((top) - #(ribcage - #(e0) - #((top)) - #("i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (list (list '#(syntax-object - t - ((top) - #(ribcage - #(e0) - #((top)) - #("i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - g1309)) - (list '#(syntax-object - if - ((top) - #(ribcage - #(e0) - #((top)) - #("i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - '#(syntax-object - t - ((top) - #(ribcage - #(e0) - #((top)) - #("i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - '#(syntax-object - t - ((top) - #(ribcage - #(e0) - #((top)) - #("i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - g1306))) - g1308) - ((lambda (g1310) - (if g1310 - (apply - (lambda (g1312 - g1311) - (list '#(syntax-object - let - ((top) - #(ribcage - #(e0 - e1) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (list (list '#(syntax-object - t - ((top) - #(ribcage - #(e0 - e1) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - g1312)) - (list '#(syntax-object - if - ((top) - #(ribcage - #(e0 - e1) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - '#(syntax-object - t - ((top) - #(ribcage - #(e0 - e1) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons g1311 - '(#(syntax-object - t - ((top) - #(ribcage - #(e0 - e1) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))))) - g1306))) - g1310) - ((lambda (g1313) - (if g1313 - (apply - (lambda (g1316 - g1314 - g1315) - (list '#(syntax-object - if - ((top) - #(ribcage - #(e0 - e1 - e2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - g1316 - (cons '#(syntax-object - begin - ((top) - #(ribcage - #(e0 - e1 - e2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons g1314 - g1315)) - g1306)) - g1313) - ((lambda (g1318) - (syntax-error - g1280)) - g1307))) - (syntax-dispatch - g1307 - '(any any - . - each-any))))) - (syntax-dispatch - g1307 - '(any #(free-id - #(syntax-object - => - ((top) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - m1 - m2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i"))))) - any))))) - (syntax-dispatch - g1307 - '(any)))) - g1288)) - g1305)) - (g1286 - (car g1287) - (cdr g1287))))))) - g1286) - g1283 - g1284)) - g1282) - (syntax-error g1281))) - (syntax-dispatch g1281 '(any any . each-any)))) - g1280))) + (lambda (syntmp-x-1703) + ((lambda (syntmp-tmp-1704) + ((lambda (syntmp-tmp-1705) + (if (if syntmp-tmp-1705 + (apply (lambda (syntmp-let*-1706 + syntmp-x-1707 + syntmp-v-1708 + syntmp-e1-1709 + syntmp-e2-1710) + (andmap identifier? syntmp-x-1707)) + syntmp-tmp-1705) + #f) + (apply (lambda (syntmp-let*-1712 + syntmp-x-1713 + syntmp-v-1714 + syntmp-e1-1715 + syntmp-e2-1716) + (let syntmp-f-1717 ((syntmp-bindings-1718 + (map list + syntmp-x-1713 + syntmp-v-1714))) + (if (null? syntmp-bindings-1718) + (cons '#(syntax-object + let + ((top) + #(ribcage () () ()) + #(ribcage + #(f bindings) + #((top) (top)) + #("i" "i")) + #(ribcage + #(let* x v e1 e2) + #((top) (top) (top) (top) (top)) + #("i" "i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")))) + (cons '() + (cons syntmp-e1-1715 syntmp-e2-1716))) + ((lambda (syntmp-tmp-1722) + ((lambda (syntmp-tmp-1723) + (if syntmp-tmp-1723 + (apply (lambda (syntmp-body-1724 + syntmp-binding-1725) + (list '#(syntax-object + let + ((top) + #(ribcage () () ()) + #(ribcage + #(body binding) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage + #(f bindings) + #((top) (top)) + #("i" "i")) + #(ribcage + #(let* x v e1 e2) + #((top) + (top) + (top) + (top) + (top)) + #("i" "i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i")))) + (list syntmp-binding-1725) + syntmp-body-1724)) + syntmp-tmp-1723) + (syntax-error syntmp-tmp-1722))) + (syntax-dispatch + syntmp-tmp-1722 + '(any any)))) + (list (syntmp-f-1717 (cdr syntmp-bindings-1718)) + (car syntmp-bindings-1718)))))) + syntmp-tmp-1705) + (syntax-error syntmp-tmp-1704))) + (syntax-dispatch + syntmp-tmp-1704 + '(any #(each (any any)) any . each-any)))) + syntmp-x-1703))) + (install-global-transformer 'do - (lambda (g1320) - ((lambda (g1321) - ((lambda (g1322) - (if g1322 - (apply - (lambda (g1329 g1323 g1328 g1324 g1327 g1325 g1326) - ((lambda (g1330) - ((lambda (g1340) - (if g1340 - (apply - (lambda (g1341) - ((lambda (g1342) - ((lambda (g1344) - (if g1344 - (apply - (lambda () - (list '#(syntax-object - let - ((top) - #(ribcage - #(step) - #((top)) - #("i")) - #(ribcage - #(_ - var - init - step - e0 - e1 - c) - #((top) - (top) - (top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i" - "i" - "i")) - #(ribcage () () ()) - #(ribcage - #(orig-x) - #((top)) - #("i")))) - '#(syntax-object - doloop - ((top) - #(ribcage - #(step) - #((top)) - #("i")) - #(ribcage - #(_ - var - init - step - e0 - e1 - c) - #((top) - (top) - (top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i" - "i" - "i")) - #(ribcage () () ()) - #(ribcage - #(orig-x) - #((top)) - #("i")))) - (map list g1323 g1328) - (list '#(syntax-object - if - ((top) - #(ribcage - #(step) - #((top)) - #("i")) - #(ribcage - #(_ - var - init - step - e0 - e1 - c) - #((top) - (top) - (top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(orig-x) - #((top)) - #("i")))) - (list '#(syntax-object - not - ((top) - #(ribcage - #(step) - #((top)) - #("i")) - #(ribcage - #(_ - var - init - step - e0 - e1 - c) - #((top) - (top) - (top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(orig-x) - #((top)) - #("i")))) - g1327) - (cons '#(syntax-object - begin - ((top) - #(ribcage - #(step) - #((top)) - #("i")) - #(ribcage - #(_ - var - init - step - e0 - e1 - c) - #((top) - (top) - (top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(orig-x) - #((top)) - #("i")))) - (append - g1326 - (list (cons '#(syntax-object - doloop - ((top) - #(ribcage - #(step) - #((top)) - #("i")) - #(ribcage - #(_ - var - init - step - e0 - e1 - c) - #((top) - (top) - (top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(orig-x) - #((top)) - #("i")))) - g1341))))))) - g1344) - ((lambda (g1349) - (if g1349 - (apply - (lambda (g1351 g1350) - (list '#(syntax-object - let - ((top) - #(ribcage - #(e1 e2) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(step) - #((top)) - #("i")) - #(ribcage - #(_ - var - init - step - e0 - e1 - c) - #((top) - (top) - (top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(orig-x) - #((top)) - #("i")))) - '#(syntax-object - doloop - ((top) - #(ribcage - #(e1 e2) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(step) - #((top)) - #("i")) - #(ribcage - #(_ - var - init - step - e0 - e1 - c) - #((top) - (top) - (top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(orig-x) - #((top)) - #("i")))) - (map list - g1323 - g1328) - (list '#(syntax-object - if - ((top) - #(ribcage - #(e1 - e2) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(step) - #((top)) - #("i")) - #(ribcage - #(_ - var - init - step - e0 - e1 - c) - #((top) - (top) - (top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(orig-x) - #((top)) - #("i")))) - g1327 - (cons '#(syntax-object - begin - ((top) - #(ribcage - #(e1 - e2) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(step) - #((top)) - #("i")) - #(ribcage - #(_ - var - init - step - e0 - e1 - c) - #((top) - (top) - (top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(orig-x) - #((top)) - #("i")))) - (cons g1351 - g1350)) - (cons '#(syntax-object - begin - ((top) - #(ribcage - #(e1 - e2) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(step) - #((top)) - #("i")) - #(ribcage - #(_ - var - init - step - e0 - e1 - c) - #((top) - (top) - (top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(orig-x) - #((top)) - #("i")))) - (append - g1326 - (list (cons '#(syntax-object - doloop - ((top) - #(ribcage - #(e1 - e2) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(step) - #((top)) - #("i")) - #(ribcage - #(_ - var - init - step - e0 - e1 - c) - #((top) - (top) - (top) - (top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(orig-x) - #((top)) - #("i")))) - g1341))))))) - g1349) - (syntax-error g1342))) - (syntax-dispatch - g1342 - '(any . each-any))))) - (syntax-dispatch g1342 '()))) - g1325)) - g1340) - (syntax-error g1330))) - (syntax-dispatch g1330 'each-any))) - (map (lambda (g1334 g1333) - ((lambda (g1335) - ((lambda (g1336) - (if g1336 - (apply (lambda () g1334) g1336) - ((lambda (g1337) - (if g1337 - (apply - (lambda (g1338) g1338) - g1337) - ((lambda (g1339) - (syntax-error g1320)) - g1335))) - (syntax-dispatch g1335 '(any))))) - (syntax-dispatch g1335 '()))) - g1333)) - g1323 - g1324))) - g1322) - (syntax-error g1321))) - (syntax-dispatch - g1321 - '(any #(each (any any . any)) - (any . each-any) - . - each-any)))) - g1320))) + (lambda (syntmp-orig-x-1745) + ((lambda (syntmp-tmp-1746) + ((lambda (syntmp-tmp-1747) + (if syntmp-tmp-1747 + (apply (lambda (syntmp-_-1748 + syntmp-var-1749 + syntmp-init-1750 + syntmp-step-1751 + syntmp-e0-1752 + syntmp-e1-1753 + syntmp-c-1754) + ((lambda (syntmp-tmp-1755) + ((lambda (syntmp-tmp-1756) + (if syntmp-tmp-1756 + (apply (lambda (syntmp-step-1757) + ((lambda (syntmp-tmp-1758) + ((lambda (syntmp-tmp-1759) + (if syntmp-tmp-1759 + (apply (lambda () + (list '#(syntax-object + let + ((top) + #(ribcage + () + () + ()) + #(ribcage + #(step) + #((top)) + #("i")) + #(ribcage + #(_ + var + init + step + e0 + e1 + c) + #((top) + (top) + (top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(orig-x) + #((top)) + #("i")))) + '#(syntax-object + doloop + ((top) + #(ribcage + () + () + ()) + #(ribcage + #(step) + #((top)) + #("i")) + #(ribcage + #(_ + var + init + step + e0 + e1 + c) + #((top) + (top) + (top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(orig-x) + #((top)) + #("i")))) + (map list + syntmp-var-1749 + syntmp-init-1750) + (list '#(syntax-object + if + ((top) + #(ribcage + () + () + ()) + #(ribcage + #(step) + #((top)) + #("i")) + #(ribcage + #(_ + var + init + step + e0 + e1 + c) + #((top) + (top) + (top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(orig-x) + #((top)) + #("i")))) + (list '#(syntax-object + not + ((top) + #(ribcage + () + () + ()) + #(ribcage + #(step) + #((top)) + #("i")) + #(ribcage + #(_ + var + init + step + e0 + e1 + c) + #((top) + (top) + (top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(orig-x) + #((top)) + #("i")))) + syntmp-e0-1752) + (cons '#(syntax-object + begin + ((top) + #(ribcage + () + () + ()) + #(ribcage + #(step) + #((top)) + #("i")) + #(ribcage + #(_ + var + init + step + e0 + e1 + c) + #((top) + (top) + (top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(orig-x) + #((top)) + #("i")))) + (append + syntmp-c-1754 + (list (cons '#(syntax-object + doloop + ((top) + #(ribcage + () + () + ()) + #(ribcage + #(step) + #((top)) + #("i")) + #(ribcage + #(_ + var + init + step + e0 + e1 + c) + #((top) + (top) + (top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(orig-x) + #((top)) + #("i")))) + syntmp-step-1757))))))) + syntmp-tmp-1759) + ((lambda (syntmp-tmp-1764) + (if syntmp-tmp-1764 + (apply (lambda (syntmp-e1-1765 + syntmp-e2-1766) + (list '#(syntax-object + let + ((top) + #(ribcage + #(e1 + e2) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(step) + #((top)) + #("i")) + #(ribcage + #(_ + var + init + step + e0 + e1 + c) + #((top) + (top) + (top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(orig-x) + #((top)) + #("i")))) + '#(syntax-object + doloop + ((top) + #(ribcage + #(e1 + e2) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(step) + #((top)) + #("i")) + #(ribcage + #(_ + var + init + step + e0 + e1 + c) + #((top) + (top) + (top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(orig-x) + #((top)) + #("i")))) + (map list + syntmp-var-1749 + syntmp-init-1750) + (list '#(syntax-object + if + ((top) + #(ribcage + #(e1 + e2) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(step) + #((top)) + #("i")) + #(ribcage + #(_ + var + init + step + e0 + e1 + c) + #((top) + (top) + (top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(orig-x) + #((top)) + #("i")))) + syntmp-e0-1752 + (cons '#(syntax-object + begin + ((top) + #(ribcage + #(e1 + e2) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(step) + #((top)) + #("i")) + #(ribcage + #(_ + var + init + step + e0 + e1 + c) + #((top) + (top) + (top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(orig-x) + #((top)) + #("i")))) + (cons syntmp-e1-1765 + syntmp-e2-1766)) + (cons '#(syntax-object + begin + ((top) + #(ribcage + #(e1 + e2) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(step) + #((top)) + #("i")) + #(ribcage + #(_ + var + init + step + e0 + e1 + c) + #((top) + (top) + (top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(orig-x) + #((top)) + #("i")))) + (append + syntmp-c-1754 + (list (cons '#(syntax-object + doloop + ((top) + #(ribcage + #(e1 + e2) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(step) + #((top)) + #("i")) + #(ribcage + #(_ + var + init + step + e0 + e1 + c) + #((top) + (top) + (top) + (top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(orig-x) + #((top)) + #("i")))) + syntmp-step-1757))))))) + syntmp-tmp-1764) + (syntax-error + syntmp-tmp-1758))) + (syntax-dispatch + syntmp-tmp-1758 + '(any . each-any))))) + (syntax-dispatch + syntmp-tmp-1758 + '()))) + syntmp-e1-1753)) + syntmp-tmp-1756) + (syntax-error syntmp-tmp-1755))) + (syntax-dispatch + syntmp-tmp-1755 + 'each-any))) + (map (lambda (syntmp-v-1773 syntmp-s-1774) + ((lambda (syntmp-tmp-1775) + ((lambda (syntmp-tmp-1776) + (if syntmp-tmp-1776 + (apply (lambda () syntmp-v-1773) + syntmp-tmp-1776) + ((lambda (syntmp-tmp-1777) + (if syntmp-tmp-1777 + (apply (lambda (syntmp-e-1778) + syntmp-e-1778) + syntmp-tmp-1777) + ((lambda (syntmp-_-1779) + (syntax-error syntmp-orig-x-1745)) + syntmp-tmp-1775))) + (syntax-dispatch + syntmp-tmp-1775 + '(any))))) + (syntax-dispatch syntmp-tmp-1775 (quote ())))) + syntmp-s-1774)) + syntmp-var-1749 + syntmp-step-1751))) + syntmp-tmp-1747) + (syntax-error syntmp-tmp-1746))) + (syntax-dispatch + syntmp-tmp-1746 + '(any #(each (any any . any)) + (any . each-any) + . + each-any)))) + syntmp-orig-x-1745))) + (install-global-transformer 'quasiquote - (letrec ((g1360 (lambda (g1399 g1398) - ((lambda (g1400) - ((lambda (g1401) - (if g1401 - (apply - (lambda (g1403 g1402) - ((lambda (g1404) - ((lambda (g1405) - (if g1405 - (apply - (lambda (g1406) - ((lambda (g1407) - ((lambda (g1408) - (if g1408 - (apply - (lambda (g1409) - (list '#(syntax-object - quote - ((top) - #(ribcage - #(dx) - #((top)) - #("i")) - #(ribcage - #(dy) - #((top)) - #("i")) - #(ribcage - #(x - y) - #((top) - (top)) - #("i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(x - y) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")))) - (cons g1409 - g1406))) - g1408) - ((lambda (g1410) - (if (null? - g1406) - (list '#(syntax-object - list - ((top) - #(ribcage - #(_) - #((top)) - #("i")) - #(ribcage - #(dy) - #((top)) - #("i")) - #(ribcage - #(x - y) - #((top) - (top)) - #("i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(x - y) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")))) - g1403) - (list '#(syntax-object - cons - ((top) - #(ribcage - #(_) - #((top)) - #("i")) - #(ribcage - #(dy) - #((top)) - #("i")) - #(ribcage - #(x - y) - #((top) - (top)) - #("i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(x - y) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")))) - g1403 - g1402))) - g1407))) - (syntax-dispatch - g1407 - '(#(free-id - #(syntax-object - quote - ((top) - #(ribcage - #(dy) - #((top)) - #("i")) - #(ribcage - #(x y) - #((top) - (top)) - #("i" "i")) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(x y) - #((top) - (top)) - #("i" "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i"))))) - any)))) - g1403)) - g1405) - ((lambda (g1411) - (if g1411 - (apply - (lambda (g1412) - (cons '#(syntax-object - list - ((top) - #(ribcage - #(stuff) - #((top)) - #("i")) - #(ribcage - #(x y) - #((top) - (top)) - #("i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(x y) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")))) - (cons g1403 - g1412))) - g1411) - ((lambda (g1413) - (list '#(syntax-object - cons - ((top) - #(ribcage - #(else) - #((top)) - #("i")) - #(ribcage - #(x y) - #((top) - (top)) - #("i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(x y) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")))) - g1403 - g1402)) - g1404))) - (syntax-dispatch - g1404 - '(#(free-id - #(syntax-object - list - ((top) - #(ribcage - #(x y) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage () () ()) - #(ribcage - #(x y) - #((top) (top)) - #("i" "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i"))))) - . - any))))) - (syntax-dispatch - g1404 - '(#(free-id - #(syntax-object - quote - ((top) - #(ribcage - #(x y) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage () () ()) - #(ribcage - #(x y) - #((top) (top)) - #("i" "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) (top) (top) (top)) - #("i" "i" "i" "i"))))) - any)))) - g1402)) - g1401) - (syntax-error g1400))) - (syntax-dispatch g1400 '(any any)))) - (list g1399 g1398)))) - (g1357 (lambda (g1362 g1361) - ((lambda (g1363) - ((lambda (g1364) - (if g1364 - (apply - (lambda (g1366 g1365) - ((lambda (g1367) - ((lambda (g1368) - (if g1368 - (apply (lambda () g1366) g1368) - ((lambda (g1369) - (list '#(syntax-object - append - ((top) - #(ribcage - #(_) - #((top)) - #("i")) - #(ribcage - #(x y) - #((top) (top)) - #("i" "i")) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(x y) - #((top) (top)) - #("i" "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")))) - g1366 - g1365)) - g1367))) - (syntax-dispatch - g1367 - '(#(free-id - #(syntax-object - quote - ((top) - #(ribcage - #(x y) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage () () ()) - #(ribcage - #(x y) - #((top) (top)) - #("i" "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) (top) (top) (top)) - #("i" "i" "i" "i"))))) - ())))) - g1365)) - g1364) - (syntax-error g1363))) - (syntax-dispatch g1363 '(any any)))) - (list g1362 g1361)))) - (g1359 (lambda (g1387) - ((lambda (g1388) - ((lambda (g1389) - ((lambda (g1390) - ((lambda (g1391) - (if g1391 - (apply - (lambda (g1392) - (list '#(syntax-object - quote - ((top) - #(ribcage - #(x) - #((top)) - #("i")) - #(ribcage - #(x) - #((top)) - #("i")) - #(ribcage () () ()) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) - (top) - (top) - (top)) - #("i" "i" "i" "i")))) - (list->vector g1392))) - g1391) - ((lambda (g1394) - (if g1394 - (apply - (lambda (g1395) - (cons '#(syntax-object - vector - ((top) - #(ribcage - #(x) - #((top)) - #("i")) - #(ribcage - #(x) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")))) - g1395)) - g1394) - ((lambda (g1397) - (list '#(syntax-object - list->vector - ((top) - #(ribcage - #(_) - #((top)) - #("i")) - #(ribcage - #(x) - #((top)) - #("i")) - #(ribcage () () ()) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")))) - g1389)) - g1390))) - (syntax-dispatch - g1390 - '(#(free-id - #(syntax-object - list - ((top) - #(ribcage - #(x) - #((top)) - #("i")) - #(ribcage () () ()) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) (top) (top) (top)) - #("i" "i" "i" "i"))))) - . - each-any))))) - (syntax-dispatch - g1390 - '(#(free-id - #(syntax-object - quote - ((top) - #(ribcage #(x) #((top)) #("i")) - #(ribcage () () ()) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) (top) (top) (top)) - #("i" "i" "i" "i"))))) - each-any)))) - g1389)) - g1388)) - g1387))) - (g1358 (lambda (g1371 g1370) - ((lambda (g1372) - ((lambda (g1373) - (if g1373 - (apply - (lambda (g1374) - (if (fx= g1370 '0) - g1374 - (g1360 - '(#(syntax-object - quote - ((top) - #(ribcage - #(p) - #((top)) - #("i")) - #(ribcage () () ()) - #(ribcage - #(p lev) - #((top) (top)) - #("i" "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) (top) (top) (top)) - #("i" "i" "i" "i")))) - #(syntax-object - unquote - ((top) - #(ribcage - #(p) - #((top)) - #("i")) - #(ribcage () () ()) - #(ribcage - #(p lev) - #((top) (top)) - #("i" "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) (top) (top) (top)) - #("i" "i" "i" "i"))))) - (g1358 - (list g1374) - (fx- g1370 '1))))) - g1373) - ((lambda (g1375) - (if g1375 - (apply - (lambda (g1377 g1376) - (if (fx= g1370 '0) - (g1357 - g1377 - (g1358 g1376 g1370)) - (g1360 - (g1360 - '(#(syntax-object - quote - ((top) - #(ribcage - #(p q) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage - #(p lev) - #((top) (top)) - #("i" "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")))) - #(syntax-object - unquote-splicing - ((top) - #(ribcage - #(p q) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage - #(p lev) - #((top) (top)) - #("i" "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i"))))) - (g1358 - (list g1377) - (fx- g1370 '1))) - (g1358 g1376 g1370)))) - g1375) - ((lambda (g1378) - (if g1378 - (apply - (lambda (g1379) - (g1360 - '(#(syntax-object - quote - ((top) - #(ribcage - #(p) - #((top)) - #("i")) - #(ribcage () () ()) - #(ribcage - #(p lev) - #((top) (top)) - #("i" "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")))) - #(syntax-object - quasiquote - ((top) - #(ribcage - #(p) - #((top)) - #("i")) - #(ribcage () () ()) - #(ribcage - #(p lev) - #((top) (top)) - #("i" "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i"))))) - (g1358 - (list g1379) - (fx+ g1370 '1)))) - g1378) - ((lambda (g1380) - (if g1380 - (apply - (lambda (g1382 g1381) - (g1360 - (g1358 - g1382 - g1370) - (g1358 - g1381 - g1370))) - g1380) - ((lambda (g1383) - (if g1383 - (apply - (lambda (g1384) - (g1359 - (g1358 - g1384 - g1370))) - g1383) - ((lambda (g1386) - (list '#(syntax-object - quote - ((top) - #(ribcage - #(p) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(p - lev) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")))) - g1386)) - g1372))) - (syntax-dispatch - g1372 - '#(vector - each-any))))) - (syntax-dispatch - g1372 - '(any . any))))) - (syntax-dispatch - g1372 - '(#(free-id - #(syntax-object - quasiquote - ((top) - #(ribcage () () ()) - #(ribcage - #(p lev) - #((top) (top)) - #("i" "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) (top) (top) (top)) - #("i" "i" "i" "i"))))) - any))))) - (syntax-dispatch - g1372 - '((#(free-id - #(syntax-object - unquote-splicing - ((top) - #(ribcage () () ()) - #(ribcage - #(p lev) - #((top) (top)) - #("i" "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) (top) (top) (top)) - #("i" "i" "i" "i"))))) - any) - . - any))))) - (syntax-dispatch - g1372 - '(#(free-id - #(syntax-object - unquote - ((top) - #(ribcage () () ()) - #(ribcage - #(p lev) - #((top) (top)) - #("i" "i")) - #(ribcage - #(quasicons - quasiappend - quasivector - quasi) - #((top) (top) (top) (top)) - #("i" "i" "i" "i"))))) - any)))) - g1371)))) - (lambda (g1414) - ((lambda (g1415) - ((lambda (g1416) - (if g1416 - (apply (lambda (g1418 g1417) (g1358 g1417 '0)) g1416) - (syntax-error g1415))) - (syntax-dispatch g1415 '(any any)))) - g1414)))) + (letrec ((syntmp-quasicons-1807 + (lambda (syntmp-x-1811 syntmp-y-1812) + ((lambda (syntmp-tmp-1813) + ((lambda (syntmp-tmp-1814) + (if syntmp-tmp-1814 + (apply (lambda (syntmp-x-1815 syntmp-y-1816) + ((lambda (syntmp-tmp-1817) + ((lambda (syntmp-tmp-1818) + (if syntmp-tmp-1818 + (apply (lambda (syntmp-dy-1819) + ((lambda (syntmp-tmp-1820) + ((lambda (syntmp-tmp-1821) + (if syntmp-tmp-1821 + (apply (lambda (syntmp-dx-1822) + (list '#(syntax-object + quote + ((top) + #(ribcage + #(dx) + #((top)) + #("i")) + #(ribcage + #(dy) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(x + y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + () + () + ()) + #(ribcage + #(x + y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")))) + (cons syntmp-dx-1822 + syntmp-dy-1819))) + syntmp-tmp-1821) + ((lambda (syntmp-_-1823) + (if (null? syntmp-dy-1819) + (list '#(syntax-object + list + ((top) + #(ribcage + #(_) + #((top)) + #("i")) + #(ribcage + #(dy) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(x + y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + () + () + ()) + #(ribcage + #(x + y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")))) + syntmp-x-1815) + (list '#(syntax-object + cons + ((top) + #(ribcage + #(_) + #((top)) + #("i")) + #(ribcage + #(dy) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(x + y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + () + () + ()) + #(ribcage + #(x + y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")))) + syntmp-x-1815 + syntmp-y-1816))) + syntmp-tmp-1820))) + (syntax-dispatch + syntmp-tmp-1820 + '(#(free-id + #(syntax-object + quote + ((top) + #(ribcage + #(dy) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(x y) + #((top) (top)) + #("i" "i")) + #(ribcage + () + () + ()) + #(ribcage + () + () + ()) + #(ribcage + #(x y) + #((top) (top)) + #("i" "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i"))))) + any)))) + syntmp-x-1815)) + syntmp-tmp-1818) + ((lambda (syntmp-tmp-1824) + (if syntmp-tmp-1824 + (apply (lambda (syntmp-stuff-1825) + (cons '#(syntax-object + list + ((top) + #(ribcage + #(stuff) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(x y) + #((top) + (top)) + #("i" "i")) + #(ribcage + () + () + ()) + #(ribcage + () + () + ()) + #(ribcage + #(x y) + #((top) + (top)) + #("i" "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")))) + (cons syntmp-x-1815 + syntmp-stuff-1825))) + syntmp-tmp-1824) + ((lambda (syntmp-else-1826) + (list '#(syntax-object + cons + ((top) + #(ribcage + #(else) + #((top)) + #("i")) + #(ribcage () () ()) + #(ribcage + #(x y) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage + #(x y) + #((top) (top)) + #("i" "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")))) + syntmp-x-1815 + syntmp-y-1816)) + syntmp-tmp-1817))) + (syntax-dispatch + syntmp-tmp-1817 + '(#(free-id + #(syntax-object + list + ((top) + #(ribcage () () ()) + #(ribcage + #(x y) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage + #(x y) + #((top) (top)) + #("i" "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) (top) (top) (top)) + #("i" "i" "i" "i"))))) + . + any))))) + (syntax-dispatch + syntmp-tmp-1817 + '(#(free-id + #(syntax-object + quote + ((top) + #(ribcage () () ()) + #(ribcage + #(x y) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage + #(x y) + #((top) (top)) + #("i" "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) (top) (top) (top)) + #("i" "i" "i" "i"))))) + any)))) + syntmp-y-1816)) + syntmp-tmp-1814) + (syntax-error syntmp-tmp-1813))) + (syntax-dispatch + syntmp-tmp-1813 + '(any any)))) + (list syntmp-x-1811 syntmp-y-1812)))) + (syntmp-quasiappend-1808 + (lambda (syntmp-x-1827 syntmp-y-1828) + ((lambda (syntmp-tmp-1829) + ((lambda (syntmp-tmp-1830) + (if syntmp-tmp-1830 + (apply (lambda (syntmp-x-1831 syntmp-y-1832) + ((lambda (syntmp-tmp-1833) + ((lambda (syntmp-tmp-1834) + (if syntmp-tmp-1834 + (apply (lambda () syntmp-x-1831) + syntmp-tmp-1834) + ((lambda (syntmp-_-1835) + (list '#(syntax-object + append + ((top) + #(ribcage + #(_) + #((top)) + #("i")) + #(ribcage () () ()) + #(ribcage + #(x y) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage + #(x y) + #((top) (top)) + #("i" "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) + (top) + (top) + (top)) + #("i" "i" "i" "i")))) + syntmp-x-1831 + syntmp-y-1832)) + syntmp-tmp-1833))) + (syntax-dispatch + syntmp-tmp-1833 + '(#(free-id + #(syntax-object + quote + ((top) + #(ribcage () () ()) + #(ribcage + #(x y) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage + #(x y) + #((top) (top)) + #("i" "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) (top) (top) (top)) + #("i" "i" "i" "i"))))) + ())))) + syntmp-y-1832)) + syntmp-tmp-1830) + (syntax-error syntmp-tmp-1829))) + (syntax-dispatch + syntmp-tmp-1829 + '(any any)))) + (list syntmp-x-1827 syntmp-y-1828)))) + (syntmp-quasivector-1809 + (lambda (syntmp-x-1836) + ((lambda (syntmp-tmp-1837) + ((lambda (syntmp-x-1838) + ((lambda (syntmp-tmp-1839) + ((lambda (syntmp-tmp-1840) + (if syntmp-tmp-1840 + (apply (lambda (syntmp-x-1841) + (list '#(syntax-object + quote + ((top) + #(ribcage #(x) #((top)) #("i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) (top) (top) (top)) + #("i" "i" "i" "i")))) + (list->vector syntmp-x-1841))) + syntmp-tmp-1840) + ((lambda (syntmp-tmp-1843) + (if syntmp-tmp-1843 + (apply (lambda (syntmp-x-1844) + (cons '#(syntax-object + vector + ((top) + #(ribcage + #(x) + #((top)) + #("i")) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i")) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) + (top) + (top) + (top)) + #("i" "i" "i" "i")))) + syntmp-x-1844)) + syntmp-tmp-1843) + ((lambda (syntmp-_-1846) + (list '#(syntax-object + list->vector + ((top) + #(ribcage #(_) #((top)) #("i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) (top) (top) (top)) + #("i" "i" "i" "i")))) + syntmp-x-1838)) + syntmp-tmp-1839))) + (syntax-dispatch + syntmp-tmp-1839 + '(#(free-id + #(syntax-object + list + ((top) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) (top) (top) (top)) + #("i" "i" "i" "i"))))) + . + each-any))))) + (syntax-dispatch + syntmp-tmp-1839 + '(#(free-id + #(syntax-object + quote + ((top) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")) + #(ribcage + #(quasicons quasiappend quasivector quasi) + #((top) (top) (top) (top)) + #("i" "i" "i" "i"))))) + each-any)))) + syntmp-x-1838)) + syntmp-tmp-1837)) + syntmp-x-1836))) + (syntmp-quasi-1810 + (lambda (syntmp-p-1847 syntmp-lev-1848) + ((lambda (syntmp-tmp-1849) + ((lambda (syntmp-tmp-1850) + (if syntmp-tmp-1850 + (apply (lambda (syntmp-p-1851) + (if (= syntmp-lev-1848 0) + syntmp-p-1851 + (syntmp-quasicons-1807 + '(#(syntax-object + quote + ((top) + #(ribcage #(p) #((top)) #("i")) + #(ribcage () () ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) (top) (top) (top)) + #("i" "i" "i" "i")))) + #(syntax-object + unquote + ((top) + #(ribcage #(p) #((top)) #("i")) + #(ribcage () () ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) (top) (top) (top)) + #("i" "i" "i" "i"))))) + (syntmp-quasi-1810 + (list syntmp-p-1851) + (- syntmp-lev-1848 1))))) + syntmp-tmp-1850) + ((lambda (syntmp-tmp-1852) + (if syntmp-tmp-1852 + (apply (lambda (syntmp-p-1853 syntmp-q-1854) + (if (= syntmp-lev-1848 0) + (syntmp-quasiappend-1808 + syntmp-p-1853 + (syntmp-quasi-1810 + syntmp-q-1854 + syntmp-lev-1848)) + (syntmp-quasicons-1807 + (syntmp-quasicons-1807 + '(#(syntax-object + quote + ((top) + #(ribcage + #(p q) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) (top) (top) (top)) + #("i" "i" "i" "i")))) + #(syntax-object + unquote-splicing + ((top) + #(ribcage + #(p q) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) (top) (top) (top)) + #("i" "i" "i" "i"))))) + (syntmp-quasi-1810 + (list syntmp-p-1853) + (- syntmp-lev-1848 1))) + (syntmp-quasi-1810 + syntmp-q-1854 + syntmp-lev-1848)))) + syntmp-tmp-1852) + ((lambda (syntmp-tmp-1855) + (if syntmp-tmp-1855 + (apply (lambda (syntmp-p-1856) + (syntmp-quasicons-1807 + '(#(syntax-object + quote + ((top) + #(ribcage + #(p) + #((top)) + #("i")) + #(ribcage () () ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) (top) (top) (top)) + #("i" "i" "i" "i")))) + #(syntax-object + quasiquote + ((top) + #(ribcage + #(p) + #((top)) + #("i")) + #(ribcage () () ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) (top) (top) (top)) + #("i" "i" "i" "i"))))) + (syntmp-quasi-1810 + (list syntmp-p-1856) + (+ syntmp-lev-1848 1)))) + syntmp-tmp-1855) + ((lambda (syntmp-tmp-1857) + (if syntmp-tmp-1857 + (apply (lambda (syntmp-p-1858 + syntmp-q-1859) + (syntmp-quasicons-1807 + (syntmp-quasi-1810 + syntmp-p-1858 + syntmp-lev-1848) + (syntmp-quasi-1810 + syntmp-q-1859 + syntmp-lev-1848))) + syntmp-tmp-1857) + ((lambda (syntmp-tmp-1860) + (if syntmp-tmp-1860 + (apply (lambda (syntmp-x-1861) + (syntmp-quasivector-1809 + (syntmp-quasi-1810 + syntmp-x-1861 + syntmp-lev-1848))) + syntmp-tmp-1860) + ((lambda (syntmp-p-1863) + (list '#(syntax-object + quote + ((top) + #(ribcage + #(p) + #((top)) + #("i")) + #(ribcage () () ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) + (top) + (top) + (top)) + #("i" "i" "i" "i")))) + syntmp-p-1863)) + syntmp-tmp-1849))) + (syntax-dispatch + syntmp-tmp-1849 + '#(vector each-any))))) + (syntax-dispatch + syntmp-tmp-1849 + '(any . any))))) + (syntax-dispatch + syntmp-tmp-1849 + '(#(free-id + #(syntax-object + quasiquote + ((top) + #(ribcage () () ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + #(quasicons + quasiappend + quasivector + quasi) + #((top) (top) (top) (top)) + #("i" "i" "i" "i"))))) + any))))) + (syntax-dispatch + syntmp-tmp-1849 + '((#(free-id + #(syntax-object + unquote-splicing + ((top) + #(ribcage () () ()) + #(ribcage #(p lev) #((top) (top)) #("i" "i")) + #(ribcage + #(quasicons quasiappend quasivector quasi) + #((top) (top) (top) (top)) + #("i" "i" "i" "i"))))) + any) + . + any))))) + (syntax-dispatch + syntmp-tmp-1849 + '(#(free-id + #(syntax-object + unquote + ((top) + #(ribcage () () ()) + #(ribcage #(p lev) #((top) (top)) #("i" "i")) + #(ribcage + #(quasicons quasiappend quasivector quasi) + #((top) (top) (top) (top)) + #("i" "i" "i" "i"))))) + any)))) + syntmp-p-1847)))) + (lambda (syntmp-x-1864) + ((lambda (syntmp-tmp-1865) + ((lambda (syntmp-tmp-1866) + (if syntmp-tmp-1866 + (apply (lambda (syntmp-_-1867 syntmp-e-1868) + (syntmp-quasi-1810 syntmp-e-1868 0)) + syntmp-tmp-1866) + (syntax-error syntmp-tmp-1865))) + (syntax-dispatch + syntmp-tmp-1865 + '(any any)))) + syntmp-x-1864)))) + (install-global-transformer 'include - (lambda (g1419) - (letrec ((g1420 (lambda (g1422 g1421) - ((lambda (g1423) - ((letrec ((g1424 (lambda (g1425) - (if (eof-object? g1425) - (begin (close-input-port - g1423) - '()) - (cons (datum->syntax-object - g1421 - g1425) - (g1424 - (read g1423))))))) - g1424) - (read g1423))) - (open-input-file g1422))))) - ((lambda (g1426) - ((lambda (g1427) - (if g1427 - (apply - (lambda (g1429 g1428) - ((lambda (g1430) - ((lambda (g1431) - ((lambda (g1432) - (if g1432 - (apply - (lambda (g1433) - (cons '#(syntax-object - begin - ((top) - #(ribcage - #(exp) - #((top)) - #("i")) - #(ribcage () () ()) - #(ribcage () () ()) - #(ribcage - #(fn) - #((top)) - #("i")) - #(ribcage - #(k filename) - #((top) (top)) - #("i" "i")) - #(ribcage - (read-file) - ((top)) - ("i")) - #(ribcage - #(x) - #((top)) - #("i")))) - g1433)) - g1432) - (syntax-error g1431))) - (syntax-dispatch g1431 'each-any))) - (g1420 g1430 g1429))) - (syntax-object->datum g1428))) - g1427) - (syntax-error g1426))) - (syntax-dispatch g1426 '(any any)))) - g1419)))) + (lambda (syntmp-x-1928) + (letrec ((syntmp-read-file-1929 + (lambda (syntmp-fn-1930 syntmp-k-1931) + (let ((syntmp-p-1932 (open-input-file syntmp-fn-1930))) + (let syntmp-f-1933 ((syntmp-x-1934 (read syntmp-p-1932))) + (if (eof-object? syntmp-x-1934) + (begin + (close-input-port syntmp-p-1932) + '()) + (cons (datum->syntax-object + syntmp-k-1931 + syntmp-x-1934) + (syntmp-f-1933 (read syntmp-p-1932))))))))) + ((lambda (syntmp-tmp-1935) + ((lambda (syntmp-tmp-1936) + (if syntmp-tmp-1936 + (apply (lambda (syntmp-k-1937 syntmp-filename-1938) + (let ((syntmp-fn-1939 + (syntax-object->datum syntmp-filename-1938))) + ((lambda (syntmp-tmp-1940) + ((lambda (syntmp-tmp-1941) + (if syntmp-tmp-1941 + (apply (lambda (syntmp-exp-1942) + (cons '#(syntax-object + begin + ((top) + #(ribcage () () ()) + #(ribcage + #(exp) + #((top)) + #("i")) + #(ribcage () () ()) + #(ribcage () () ()) + #(ribcage + #(fn) + #((top)) + #("i")) + #(ribcage + #(k filename) + #((top) (top)) + #("i" "i")) + #(ribcage + (read-file) + ((top)) + ("i")) + #(ribcage + #(x) + #((top)) + #("i")))) + syntmp-exp-1942)) + syntmp-tmp-1941) + (syntax-error syntmp-tmp-1940))) + (syntax-dispatch + syntmp-tmp-1940 + 'each-any))) + (syntmp-read-file-1929 + syntmp-fn-1939 + syntmp-k-1937)))) + syntmp-tmp-1936) + (syntax-error syntmp-tmp-1935))) + (syntax-dispatch + syntmp-tmp-1935 + '(any any)))) + syntmp-x-1928)))) + (install-global-transformer 'unquote - (lambda (g1435) - ((lambda (g1436) - ((lambda (g1437) - (if g1437 - (apply - (lambda (g1439 g1438) - (error 'unquote - '"expression ,~s not valid outside of quasiquote" - (syntax-object->datum g1438))) - g1437) - (syntax-error g1436))) - (syntax-dispatch g1436 '(any any)))) - g1435))) + (lambda (syntmp-x-1959) + ((lambda (syntmp-tmp-1960) + ((lambda (syntmp-tmp-1961) + (if syntmp-tmp-1961 + (apply (lambda (syntmp-_-1962 syntmp-e-1963) + (error 'unquote + "expression ,~s not valid outside of quasiquote" + (syntax-object->datum syntmp-e-1963))) + syntmp-tmp-1961) + (syntax-error syntmp-tmp-1960))) + (syntax-dispatch + syntmp-tmp-1960 + '(any any)))) + syntmp-x-1959))) + (install-global-transformer 'unquote-splicing - (lambda (g1440) - ((lambda (g1441) - ((lambda (g1442) - (if g1442 - (apply - (lambda (g1444 g1443) - (error 'unquote-splicing - '"expression ,@~s not valid outside of quasiquote" - (syntax-object->datum g1443))) - g1442) - (syntax-error g1441))) - (syntax-dispatch g1441 '(any any)))) - g1440))) + (lambda (syntmp-x-1969) + ((lambda (syntmp-tmp-1970) + ((lambda (syntmp-tmp-1971) + (if syntmp-tmp-1971 + (apply (lambda (syntmp-_-1972 syntmp-e-1973) + (error 'unquote-splicing + "expression ,@~s not valid outside of quasiquote" + (syntax-object->datum syntmp-e-1973))) + syntmp-tmp-1971) + (syntax-error syntmp-tmp-1970))) + (syntax-dispatch + syntmp-tmp-1970 + '(any any)))) + syntmp-x-1969))) + (install-global-transformer 'case - (lambda (g1445) - ((lambda (g1446) - ((lambda (g1447) - (if g1447 - (apply - (lambda (g1451 g1448 g1450 g1449) - ((lambda (g1452) - ((lambda (g1479) - (list '#(syntax-object - let - ((top) - #(ribcage #(body) #((top)) #("i")) - #(ribcage - #(_ e m1 m2) - #((top) (top) (top) (top)) - #("i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")))) - (list (list '#(syntax-object - t - ((top) - #(ribcage - #(body) - #((top)) - #("i")) - #(ribcage - #(_ e m1 m2) - #((top) (top) (top) (top)) - #("i" "i" "i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))) - g1448)) - g1479)) - g1452)) - ((letrec ((g1453 (lambda (g1455 g1454) - (if (null? g1454) - ((lambda (g1456) - ((lambda (g1457) - (if g1457 - (apply - (lambda (g1459 g1458) - (cons '#(syntax-object - begin - ((top) - #(ribcage - #(e1 - e2) - #((top) - (top)) - #("i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - e - m1 - m2) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons g1459 - g1458))) - g1457) - ((lambda (g1461) - (if g1461 - (apply - (lambda (g1464 - g1462 - g1463) - (list '#(syntax-object - if - ((top) - #(ribcage - #(k - e1 - e2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - e - m1 - m2) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (list '#(syntax-object - memv - ((top) - #(ribcage - #(k - e1 - e2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - e - m1 - m2) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - '#(syntax-object - t - ((top) - #(ribcage - #(k - e1 - e2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - e - m1 - m2) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (list '#(syntax-object - quote - ((top) - #(ribcage - #(k - e1 - e2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - e - m1 - m2) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - g1464)) - (cons '#(syntax-object - begin - ((top) - #(ribcage - #(k - e1 - e2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - e - m1 - m2) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons g1462 - g1463)))) - g1461) - ((lambda (g1467) - (syntax-error - g1445)) - g1456))) - (syntax-dispatch - g1456 - '(each-any - any - . - each-any))))) - (syntax-dispatch - g1456 - '(#(free-id - #(syntax-object - else - ((top) - #(ribcage () () ()) - #(ribcage - #(clause clauses) - #((top) (top)) - #("i" "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ e m1 m2) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i"))))) - any - . - each-any)))) - g1455) - ((lambda (g1468) - ((lambda (g1469) - ((lambda (g1470) - ((lambda (g1471) - (if g1471 - (apply - (lambda (g1474 - g1472 - g1473) - (list '#(syntax-object - if - ((top) - #(ribcage - #(k - e1 - e2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - e - m1 - m2) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (list '#(syntax-object - memv - ((top) - #(ribcage - #(k - e1 - e2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - e - m1 - m2) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - '#(syntax-object - t - ((top) - #(ribcage - #(k - e1 - e2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - e - m1 - m2) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (list '#(syntax-object - quote - ((top) - #(ribcage - #(k - e1 - e2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - e - m1 - m2) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - g1474)) - (cons '#(syntax-object - begin - ((top) - #(ribcage - #(k - e1 - e2) - #((top) - (top) - (top)) - #("i" - "i" - "i")) - #(ribcage - #(rest) - #((top)) - #("i")) - #(ribcage - () - () - ()) - #(ribcage - #(clause - clauses) - #((top) - (top)) - #("i" - "i")) - #(ribcage - #(f) - #((top)) - #("i")) - #(ribcage - #(_ - e - m1 - m2) - #((top) - (top) - (top) - (top)) - #("i" - "i" - "i" - "i")) - #(ribcage - () - () - ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons g1472 - g1473)) - g1469)) - g1471) - ((lambda (g1477) - (syntax-error - g1445)) - g1470))) - (syntax-dispatch - g1470 - '(each-any - any - . - each-any)))) - g1455)) - g1468)) - (g1453 - (car g1454) - (cdr g1454))))))) - g1453) - g1450 - g1449))) - g1447) - (syntax-error g1446))) - (syntax-dispatch g1446 '(any any any . each-any)))) - g1445))) + (lambda (syntmp-x-1979) + ((lambda (syntmp-tmp-1980) + ((lambda (syntmp-tmp-1981) + (if syntmp-tmp-1981 + (apply (lambda (syntmp-_-1982 + syntmp-e-1983 + syntmp-m1-1984 + syntmp-m2-1985) + ((lambda (syntmp-tmp-1986) + ((lambda (syntmp-body-1987) + (list '#(syntax-object + let + ((top) + #(ribcage () () ()) + #(ribcage #(body) #((top)) #("i")) + #(ribcage + #(_ e m1 m2) + #((top) (top) (top) (top)) + #("i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")))) + (list (list '#(syntax-object + t + ((top) + #(ribcage () () ()) + #(ribcage + #(body) + #((top)) + #("i")) + #(ribcage + #(_ e m1 m2) + #((top) (top) (top) (top)) + #("i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i")))) + syntmp-e-1983)) + syntmp-body-1987)) + syntmp-tmp-1986)) + (let syntmp-f-1988 ((syntmp-clause-1989 syntmp-m1-1984) + (syntmp-clauses-1990 syntmp-m2-1985)) + (if (null? syntmp-clauses-1990) + ((lambda (syntmp-tmp-1992) + ((lambda (syntmp-tmp-1993) + (if syntmp-tmp-1993 + (apply (lambda (syntmp-e1-1994 + syntmp-e2-1995) + (cons '#(syntax-object + begin + ((top) + #(ribcage + #(e1 e2) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage + #(f clause clauses) + #((top) (top) (top)) + #("i" "i" "i")) + #(ribcage + #(_ e m1 m2) + #((top) + (top) + (top) + (top)) + #("i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i")))) + (cons syntmp-e1-1994 + syntmp-e2-1995))) + syntmp-tmp-1993) + ((lambda (syntmp-tmp-1997) + (if syntmp-tmp-1997 + (apply (lambda (syntmp-k-1998 + syntmp-e1-1999 + syntmp-e2-2000) + (list '#(syntax-object + if + ((top) + #(ribcage + #(k e1 e2) + #((top) + (top) + (top)) + #("i" "i" "i")) + #(ribcage () () ()) + #(ribcage + #(f clause clauses) + #((top) + (top) + (top)) + #("i" "i" "i")) + #(ribcage + #(_ e m1 m2) + #((top) + (top) + (top) + (top)) + #("i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i")))) + (list '#(syntax-object + memv + ((top) + #(ribcage + #(k e1 e2) + #((top) + (top) + (top)) + #("i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(f + clause + clauses) + #((top) + (top) + (top)) + #("i" + "i" + "i")) + #(ribcage + #(_ e m1 m2) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(x) + #((top)) + #("i")))) + '#(syntax-object + t + ((top) + #(ribcage + #(k e1 e2) + #((top) + (top) + (top)) + #("i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(f + clause + clauses) + #((top) + (top) + (top)) + #("i" + "i" + "i")) + #(ribcage + #(_ e m1 m2) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(x) + #((top)) + #("i")))) + (list '#(syntax-object + quote + ((top) + #(ribcage + #(k + e1 + e2) + #((top) + (top) + (top)) + #("i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(f + clause + clauses) + #((top) + (top) + (top)) + #("i" + "i" + "i")) + #(ribcage + #(_ + e + m1 + m2) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(x) + #((top)) + #("i")))) + syntmp-k-1998)) + (cons '#(syntax-object + begin + ((top) + #(ribcage + #(k e1 e2) + #((top) + (top) + (top)) + #("i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(f + clause + clauses) + #((top) + (top) + (top)) + #("i" + "i" + "i")) + #(ribcage + #(_ e m1 m2) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(x) + #((top)) + #("i")))) + (cons syntmp-e1-1999 + syntmp-e2-2000)))) + syntmp-tmp-1997) + ((lambda (syntmp-_-2003) + (syntax-error syntmp-x-1979)) + syntmp-tmp-1992))) + (syntax-dispatch + syntmp-tmp-1992 + '(each-any any . each-any))))) + (syntax-dispatch + syntmp-tmp-1992 + '(#(free-id + #(syntax-object + else + ((top) + #(ribcage () () ()) + #(ribcage + #(f clause clauses) + #((top) (top) (top)) + #("i" "i" "i")) + #(ribcage + #(_ e m1 m2) + #((top) (top) (top) (top)) + #("i" "i" "i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i"))))) + any + . + each-any)))) + syntmp-clause-1989) + ((lambda (syntmp-tmp-2004) + ((lambda (syntmp-rest-2005) + ((lambda (syntmp-tmp-2006) + ((lambda (syntmp-tmp-2007) + (if syntmp-tmp-2007 + (apply (lambda (syntmp-k-2008 + syntmp-e1-2009 + syntmp-e2-2010) + (list '#(syntax-object + if + ((top) + #(ribcage + #(k e1 e2) + #((top) + (top) + (top)) + #("i" "i" "i")) + #(ribcage () () ()) + #(ribcage + #(rest) + #((top)) + #("i")) + #(ribcage () () ()) + #(ribcage + #(f + clause + clauses) + #((top) + (top) + (top)) + #("i" "i" "i")) + #(ribcage + #(_ e m1 m2) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i")))) + (list '#(syntax-object + memv + ((top) + #(ribcage + #(k e1 e2) + #((top) + (top) + (top)) + #("i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(rest) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(f + clause + clauses) + #((top) + (top) + (top)) + #("i" + "i" + "i")) + #(ribcage + #(_ e m1 m2) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(x) + #((top)) + #("i")))) + '#(syntax-object + t + ((top) + #(ribcage + #(k e1 e2) + #((top) + (top) + (top)) + #("i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(rest) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(f + clause + clauses) + #((top) + (top) + (top)) + #("i" + "i" + "i")) + #(ribcage + #(_ e m1 m2) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(x) + #((top)) + #("i")))) + (list '#(syntax-object + quote + ((top) + #(ribcage + #(k + e1 + e2) + #((top) + (top) + (top)) + #("i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(rest) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(f + clause + clauses) + #((top) + (top) + (top)) + #("i" + "i" + "i")) + #(ribcage + #(_ + e + m1 + m2) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(x) + #((top)) + #("i")))) + syntmp-k-2008)) + (cons '#(syntax-object + begin + ((top) + #(ribcage + #(k e1 e2) + #((top) + (top) + (top)) + #("i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(rest) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(f + clause + clauses) + #((top) + (top) + (top)) + #("i" + "i" + "i")) + #(ribcage + #(_ e m1 m2) + #((top) + (top) + (top) + (top)) + #("i" + "i" + "i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(x) + #((top)) + #("i")))) + (cons syntmp-e1-2009 + syntmp-e2-2010)) + syntmp-rest-2005)) + syntmp-tmp-2007) + ((lambda (syntmp-_-2013) + (syntax-error syntmp-x-1979)) + syntmp-tmp-2006))) + (syntax-dispatch + syntmp-tmp-2006 + '(each-any any . each-any)))) + syntmp-clause-1989)) + syntmp-tmp-2004)) + (syntmp-f-1988 + (car syntmp-clauses-1990) + (cdr syntmp-clauses-1990))))))) + syntmp-tmp-1981) + (syntax-error syntmp-tmp-1980))) + (syntax-dispatch + syntmp-tmp-1980 + '(any any any . each-any)))) + syntmp-x-1979))) + (install-global-transformer 'identifier-syntax - (lambda (g1480) - ((lambda (g1481) - ((lambda (g1482) - (if g1482 - (apply - (lambda (g1484 g1483) - (list '#(syntax-object - lambda - ((top) - #(ribcage #(_ e) #((top) (top)) #("i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")))) - '(#(syntax-object - x - ((top) - #(ribcage #(_ e) #((top) (top)) #("i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i"))))) - (list '#(syntax-object - syntax-case - ((top) - #(ribcage - #(_ e) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")))) - '#(syntax-object - x - ((top) - #(ribcage - #(_ e) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")))) - '() - (list '#(syntax-object - id - ((top) - #(ribcage - #(_ e) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")))) - '(#(syntax-object - identifier? - ((top) - #(ribcage - #(_ e) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage #(x) #((top)) #("i")))) - (#(syntax-object - syntax - ((top) - #(ribcage - #(_ e) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))) - #(syntax-object - id - ((top) - #(ribcage - #(_ e) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))))) - (list '#(syntax-object - syntax - ((top) - #(ribcage - #(_ e) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))) - g1483)) - (list (cons g1484 - '(#(syntax-object - x - ((top) - #(ribcage - #(_ e) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))) - #(syntax-object - ... - ((top) - #(ribcage - #(_ e) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))))) - (list '#(syntax-object - syntax - ((top) - #(ribcage - #(_ e) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))) - (cons g1483 - '(#(syntax-object - x - ((top) - #(ribcage - #(_ e) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i")))) - #(syntax-object - ... - ((top) - #(ribcage - #(_ e) - #((top) (top)) - #("i" "i")) - #(ribcage () () ()) - #(ribcage - #(x) - #((top)) - #("i"))))))))))) - g1482) - (syntax-error g1481))) - (syntax-dispatch g1481 '(any any)))) - g1480))) + (lambda (syntmp-x-2043) + ((lambda (syntmp-tmp-2044) + ((lambda (syntmp-tmp-2045) + (if syntmp-tmp-2045 + (apply (lambda (syntmp-_-2046 syntmp-e-2047) + (list '#(syntax-object + lambda + ((top) + #(ribcage #(_ e) #((top) (top)) #("i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")))) + '(#(syntax-object + x + ((top) + #(ribcage #(_ e) #((top) (top)) #("i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i"))))) + (list '#(syntax-object + syntax-case + ((top) + #(ribcage + #(_ e) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")))) + '#(syntax-object + x + ((top) + #(ribcage + #(_ e) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")))) + '() + (list '#(syntax-object + id + ((top) + #(ribcage + #(_ e) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")))) + '(#(syntax-object + identifier? + ((top) + #(ribcage + #(_ e) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")))) + (#(syntax-object + syntax + ((top) + #(ribcage + #(_ e) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")))) + #(syntax-object + id + ((top) + #(ribcage + #(_ e) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i")))))) + (list '#(syntax-object + syntax + ((top) + #(ribcage + #(_ e) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i")))) + syntmp-e-2047)) + (list (cons syntmp-_-2046 + '(#(syntax-object + x + ((top) + #(ribcage + #(_ e) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i")))) + #(syntax-object + ... + ((top) + #(ribcage + #(_ e) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i")))))) + (list '#(syntax-object + syntax + ((top) + #(ribcage + #(_ e) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i")))) + (cons syntmp-e-2047 + '(#(syntax-object + x + ((top) + #(ribcage + #(_ e) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i")))) + #(syntax-object + ... + ((top) + #(ribcage + #(_ e) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage + #(x) + #((top)) + #("i"))))))))))) + syntmp-tmp-2045) + (syntax-error syntmp-tmp-2044))) + (syntax-dispatch + syntmp-tmp-2044 + '(any any)))) + syntmp-x-2043))) + diff --git a/module/mes/psyntax.ss b/module/mes/psyntax.ss index 7173170b..b0c7fa67 100644 --- a/module/mes/psyntax.ss +++ b/module/mes/psyntax.ss @@ -1,7 +1,32 @@ +;;;; -*-scheme-*- +;;;; +;;;; Copyright (C) 2001, 2003, 2006 Free Software Foundation, Inc. +;;;; +;;;; This library is free software; you can redistribute it and/or +;;;; modify it under the terms of the GNU Lesser General Public +;;;; License as published by the Free Software Foundation; either +;;;; version 2.1 of the License, or (at your option) any later version. +;;;; +;;;; This library is distributed in the hope that it will be useful, +;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +;;;; Lesser General Public License for more details. +;;;; +;;;; You should have received a copy of the GNU Lesser General Public +;;;; License along with this library; if not, write to the Free Software +;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +;;;; + + ;;; Portable implementation of syntax-case ;;; Extracted from Chez Scheme Version 5.9f ;;; Authors: R. Kent Dybvig, Oscar Waddell, Bob Hieb, Carl Bruggeman +;;; Modified by Mikael Djurfeldt according +;;; to the ChangeLog distributed in the same directory as this file: +;;; 1997-08-19, 1997-09-03, 1997-09-10, 2000-08-13, 2000-08-24, +;;; 2000-09-12, 2001-03-08 + ;;; Copyright (c) 1992-1997 Cadence Research Systems ;;; Permission to copy this software, in whole or in part, to use this ;;; software for any lawful purpose, and to redistribute this software @@ -102,6 +127,13 @@ ;;; evaluator/expander that no expansion is necessary, since expr has ;;; already been fully expanded to core forms. ;;; +;;; eval will not be invoked during the loading of psyntax.pp. After +;;; psyntax.pp has been loaded, the expansion of any macro definition, +;;; whether local or global, will result in a call to eval. If, however, +;;; sc-expand has already been registered as the expander to be used +;;; by eval, and eval accepts one argument, nothing special must be done +;;; to support the "noexpand" flag, since it is handled by sc-expand. +;;; ;;; (error who format-string why what) ;;; where who is either a symbol or #f, format-string is always "~a ~s", ;;; why is always a string, and what may be any object. error should @@ -127,6 +159,12 @@ ;;; the code below, but to avoid bootstrapping problems, do so only ;;; after you have a working version of the expander. +;;; Chez Scheme allows the syntactic form (syntax